pulumi-ise 0.1.0__py3-none-any.whl → 0.1.0a1715070880__py3-none-any.whl

pulumi_ise/deviceadmin/outputs.py

@@ -11,38 +11,14 @@ from .. import _utilities
 from . import outputs
 
 __all__ = [
-    'AuthenticationRuleChildren',
-    'AuthenticationRuleChildrenChildren',
-    'AuthorizationExceptionRuleChildren',
-    'AuthorizationExceptionRuleChildrenChildren',
-    'AuthorizationGlobalExceptionRuleChildren',
-    'AuthorizationGlobalExceptionRuleChildrenChildren',
-    'AuthorizationRuleChildren',
-    'AuthorizationRuleChildrenChildren',
     'ConditionChildren',
     'ConditionChildrenChildren',
-    'PolicySetChildren',
-    'PolicySetChildrenChildren',
-    'TacacsCommandSetCommand',
-    'TacacsProfileSessionAttribute',
-    'GetAuthenticationRuleChildrenResult',
-    'GetAuthenticationRuleChildrenChildrenResult',
-    'GetAuthorizationExceptionRuleChildrenResult',
-    'GetAuthorizationExceptionRuleChildrenChildrenResult',
-    'GetAuthorizationGlobalExceptionRuleChildrenResult',
-    'GetAuthorizationGlobalExceptionRuleChildrenChildrenResult',
-    'GetAuthorizationRuleChildrenResult',
-    'GetAuthorizationRuleChildrenChildrenResult',
     'GetConditionChildrenResult',
     'GetConditionChildrenChildrenResult',
-    'GetPolicySetChildrenResult',
-    'GetPolicySetChildrenChildrenResult',
-    'GetTacacsCommandSetCommandResult',
-    'GetTacacsProfileSessionAttributeResult',
 ]
 
 @pulumi.output_type
-class AuthenticationRuleChildren(dict):
+class ConditionChildren(dict):
     @staticmethod
     def __key_warning(key: str):
         suggest = None
@@ -60,36 +36,40 @@ class AuthenticationRuleChildren(dict):
             suggest = "is_negate"
 
         if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in AuthenticationRuleChildren. Access the value via the '{suggest}' property getter instead.")
+            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:
-        AuthenticationRuleChildren.__key_warning(key)
+        ConditionChildren.__key_warning(key)
         return super().__getitem__(key)
 
     def get(self, key: str, default = None) -> Any:
-        AuthenticationRuleChildren.__key_warning(key)
+        ConditionChildren.__key_warning(key)
         return super().get(key, default)
 
     def __init__(__self__, *,
                  condition_type: str,
                  attribute_name: Optional[str] = None,
                  attribute_value: Optional[str] = None,
-                 childrens: Optional[Sequence['outputs.AuthenticationRuleChildrenChildren']] = None,
+                 childrens: Optional[Sequence['outputs.ConditionChildrenChildren']] = None,
+                 description: Optional[str] = None,
                  dictionary_name: Optional[str] = None,
                  dictionary_value: Optional[str] = None,
                  id: Optional[str] = None,
                  is_negate: Optional[bool] = None,
+                 name: Optional[str] = None,
                  operator: Optional[str] = None):
         """
         :param 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 str attribute_name: Dictionary attribute name
         :param 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 Sequence['ConditionChildrenChildrenArgs'] childrens: List of child conditions. `condition_type` must be one of `ConditionAndBlock` or `ConditionOrBlock`.
+        :param str description: Condition description
         :param str dictionary_name: Dictionary name
         :param str dictionary_value: Dictionary value
         :param str id: UUID for condition
         :param bool is_negate: Indicates whereas this condition is in negate mode
+        :param str name: Condition name
         :param str operator: Equality operator
                  - Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
         """
@@ -100,6 +80,8 @@ class AuthenticationRuleChildren(dict):
             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:
@@ -108,2585 +90,23 @@ class AuthenticationRuleChildren(dict):
             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) -> 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[str]:
-        """
-        Dictionary attribute name
-        """
-        return pulumi.get(self, "attribute_name")
-
-    @property
-    @pulumi.getter(name="attributeValue")
-    def attribute_value(self) -> Optional[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[str]:
-        """
-        Dictionary name
-        """
-        return pulumi.get(self, "dictionary_name")
-
-    @property
-    @pulumi.getter(name="dictionaryValue")
-    def dictionary_value(self) -> Optional[str]:
-        """
-        Dictionary value
-        """
-        return pulumi.get(self, "dictionary_value")
-
-    @property
-    @pulumi.getter
-    def id(self) -> Optional[str]:
-        """
-        UUID for condition
-        """
-        return pulumi.get(self, "id")
-
-    @property
-    @pulumi.getter(name="isNegate")
-    def is_negate(self) -> Optional[bool]:
-        """
-        Indicates whereas this condition is in negate mode
-        """
-        return pulumi.get(self, "is_negate")
-
-    @property
-    @pulumi.getter
-    def operator(self) -> Optional[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: str,
-                 attribute_name: Optional[str] = None,
-                 attribute_value: Optional[str] = None,
-                 dictionary_name: Optional[str] = None,
-                 dictionary_value: Optional[str] = None,
-                 id: Optional[str] = None,
-                 is_negate: Optional[bool] = None,
-                 operator: Optional[str] = None):
-        """
-        :param str condition_type: Condition type.
-                 - Choices: `ConditionAttributes`, `ConditionReference`
-        :param str attribute_name: Dictionary attribute name
-        :param str attribute_value: Attribute value for condition. Value type is specified in dictionary object.
-        :param str dictionary_name: Dictionary name
-        :param str dictionary_value: Dictionary value
-        :param str id: UUID for condition
-        :param bool is_negate: Indicates whereas this condition is in negate mode
-        :param 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) -> str:
-        """
-        Condition type.
-          - Choices: `ConditionAttributes`, `ConditionReference`
-        """
-        return pulumi.get(self, "condition_type")
-
-    @property
-    @pulumi.getter(name="attributeName")
-    def attribute_name(self) -> Optional[str]:
-        """
-        Dictionary attribute name
-        """
-        return pulumi.get(self, "attribute_name")
-
-    @property
-    @pulumi.getter(name="attributeValue")
-    def attribute_value(self) -> Optional[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[str]:
-        """
-        Dictionary name
-        """
-        return pulumi.get(self, "dictionary_name")
-
-    @property
-    @pulumi.getter(name="dictionaryValue")
-    def dictionary_value(self) -> Optional[str]:
-        """
-        Dictionary value
-        """
-        return pulumi.get(self, "dictionary_value")
-
-    @property
-    @pulumi.getter
-    def id(self) -> Optional[str]:
-        """
-        UUID for condition
-        """
-        return pulumi.get(self, "id")
-
-    @property
-    @pulumi.getter(name="isNegate")
-    def is_negate(self) -> Optional[bool]:
-        """
-        Indicates whereas this condition is in negate mode
-        """
-        return pulumi.get(self, "is_negate")
-
-    @property
-    @pulumi.getter
-    def operator(self) -> Optional[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: str,
-                 attribute_name: Optional[str] = None,
-                 attribute_value: Optional[str] = None,
-                 childrens: Optional[Sequence['outputs.AuthorizationExceptionRuleChildrenChildren']] = None,
-                 dictionary_name: Optional[str] = None,
-                 dictionary_value: Optional[str] = None,
-                 id: Optional[str] = None,
-                 is_negate: Optional[bool] = None,
-                 operator: Optional[str] = None):
-        """
-        :param 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 str attribute_name: Dictionary attribute name
-        :param 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 str dictionary_name: Dictionary name
-        :param str dictionary_value: Dictionary value
-        :param str id: UUID for condition
-        :param bool is_negate: Indicates whereas this condition is in negate mode
-        :param 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) -> 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[str]:
-        """
-        Dictionary attribute name
-        """
-        return pulumi.get(self, "attribute_name")
-
-    @property
-    @pulumi.getter(name="attributeValue")
-    def attribute_value(self) -> Optional[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[str]:
-        """
-        Dictionary name
-        """
-        return pulumi.get(self, "dictionary_name")
-
-    @property
-    @pulumi.getter(name="dictionaryValue")
-    def dictionary_value(self) -> Optional[str]:
-        """
-        Dictionary value
-        """
-        return pulumi.get(self, "dictionary_value")
-
-    @property
-    @pulumi.getter
-    def id(self) -> Optional[str]:
-        """
-        UUID for condition
-        """
-        return pulumi.get(self, "id")
-
-    @property
-    @pulumi.getter(name="isNegate")
-    def is_negate(self) -> Optional[bool]:
-        """
-        Indicates whereas this condition is in negate mode
-        """
-        return pulumi.get(self, "is_negate")
-
-    @property
-    @pulumi.getter
-    def operator(self) -> Optional[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: str,
-                 attribute_name: Optional[str] = None,
-                 attribute_value: Optional[str] = None,
-                 dictionary_name: Optional[str] = None,
-                 dictionary_value: Optional[str] = None,
-                 id: Optional[str] = None,
-                 is_negate: Optional[bool] = None,
-                 operator: Optional[str] = None):
-        """
-        :param str condition_type: Condition type.
-                 - Choices: `ConditionAttributes`, `ConditionReference`
-        :param str attribute_name: Dictionary attribute name
-        :param str attribute_value: Attribute value for condition. Value type is specified in dictionary object.
-        :param str dictionary_name: Dictionary name
-        :param str dictionary_value: Dictionary value
-        :param str id: UUID for condition
-        :param bool is_negate: Indicates whereas this condition is in negate mode
-        :param 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) -> str:
-        """
-        Condition type.
-          - Choices: `ConditionAttributes`, `ConditionReference`
-        """
-        return pulumi.get(self, "condition_type")
-
-    @property
-    @pulumi.getter(name="attributeName")
-    def attribute_name(self) -> Optional[str]:
-        """
-        Dictionary attribute name
-        """
-        return pulumi.get(self, "attribute_name")
-
-    @property
-    @pulumi.getter(name="attributeValue")
-    def attribute_value(self) -> Optional[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[str]:
-        """
-        Dictionary name
-        """
-        return pulumi.get(self, "dictionary_name")
-
-    @property
-    @pulumi.getter(name="dictionaryValue")
-    def dictionary_value(self) -> Optional[str]:
-        """
-        Dictionary value
-        """
-        return pulumi.get(self, "dictionary_value")
-
-    @property
-    @pulumi.getter
-    def id(self) -> Optional[str]:
-        """
-        UUID for condition
-        """
-        return pulumi.get(self, "id")
-
-    @property
-    @pulumi.getter(name="isNegate")
-    def is_negate(self) -> Optional[bool]:
-        """
-        Indicates whereas this condition is in negate mode
-        """
-        return pulumi.get(self, "is_negate")
-
-    @property
-    @pulumi.getter
-    def operator(self) -> Optional[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: str,
-                 attribute_name: Optional[str] = None,
-                 attribute_value: Optional[str] = None,
-                 childrens: Optional[Sequence['outputs.AuthorizationGlobalExceptionRuleChildrenChildren']] = None,
-                 dictionary_name: Optional[str] = None,
-                 dictionary_value: Optional[str] = None,
-                 id: Optional[str] = None,
-                 is_negate: Optional[bool] = None,
-                 operator: Optional[str] = None):
-        """
-        :param 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 str attribute_name: Dictionary attribute name
-        :param 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 str dictionary_name: Dictionary name
-        :param str dictionary_value: Dictionary value
-        :param str id: UUID for condition
-        :param bool is_negate: Indicates whereas this condition is in negate mode
-        :param 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) -> 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[str]:
-        """
-        Dictionary attribute name
-        """
-        return pulumi.get(self, "attribute_name")
-
-    @property
-    @pulumi.getter(name="attributeValue")
-    def attribute_value(self) -> Optional[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[str]:
-        """
-        Dictionary name
-        """
-        return pulumi.get(self, "dictionary_name")
-
-    @property
-    @pulumi.getter(name="dictionaryValue")
-    def dictionary_value(self) -> Optional[str]:
-        """
-        Dictionary value
-        """
-        return pulumi.get(self, "dictionary_value")
-
-    @property
-    @pulumi.getter
-    def id(self) -> Optional[str]:
-        """
-        UUID for condition
-        """
-        return pulumi.get(self, "id")
-
-    @property
-    @pulumi.getter(name="isNegate")
-    def is_negate(self) -> Optional[bool]:
-        """
-        Indicates whereas this condition is in negate mode
-        """
-        return pulumi.get(self, "is_negate")
-
-    @property
-    @pulumi.getter
-    def operator(self) -> Optional[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: str,
-                 attribute_name: Optional[str] = None,
-                 attribute_value: Optional[str] = None,
-                 dictionary_name: Optional[str] = None,
-                 dictionary_value: Optional[str] = None,
-                 id: Optional[str] = None,
-                 is_negate: Optional[bool] = None,
-                 operator: Optional[str] = None):
-        """
-        :param str condition_type: Condition type.
-                 - Choices: `ConditionAttributes`, `ConditionReference`
-        :param str attribute_name: Dictionary attribute name
-        :param str attribute_value: Attribute value for condition. Value type is specified in dictionary object.
-        :param str dictionary_name: Dictionary name
-        :param str dictionary_value: Dictionary value
-        :param str id: UUID for condition
-        :param bool is_negate: Indicates whereas this condition is in negate mode
-        :param 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) -> str:
-        """
-        Condition type.
-          - Choices: `ConditionAttributes`, `ConditionReference`
-        """
-        return pulumi.get(self, "condition_type")
-
-    @property
-    @pulumi.getter(name="attributeName")
-    def attribute_name(self) -> Optional[str]:
-        """
-        Dictionary attribute name
-        """
-        return pulumi.get(self, "attribute_name")
-
-    @property
-    @pulumi.getter(name="attributeValue")
-    def attribute_value(self) -> Optional[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[str]:
-        """
-        Dictionary name
-        """
-        return pulumi.get(self, "dictionary_name")
-
-    @property
-    @pulumi.getter(name="dictionaryValue")
-    def dictionary_value(self) -> Optional[str]:
-        """
-        Dictionary value
-        """
-        return pulumi.get(self, "dictionary_value")
-
-    @property
-    @pulumi.getter
-    def id(self) -> Optional[str]:
-        """
-        UUID for condition
-        """
-        return pulumi.get(self, "id")
-
-    @property
-    @pulumi.getter(name="isNegate")
-    def is_negate(self) -> Optional[bool]:
-        """
-        Indicates whereas this condition is in negate mode
-        """
-        return pulumi.get(self, "is_negate")
-
-    @property
-    @pulumi.getter
-    def operator(self) -> Optional[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 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: str,
-                 attribute_name: Optional[str] = None,
-                 attribute_value: Optional[str] = None,
-                 childrens: Optional[Sequence['outputs.AuthorizationRuleChildrenChildren']] = None,
-                 dictionary_name: Optional[str] = None,
-                 dictionary_value: Optional[str] = None,
-                 id: Optional[str] = None,
-                 is_negate: Optional[bool] = None,
-                 operator: Optional[str] = None):
-        """
-        :param 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 str attribute_name: Dictionary attribute name
-        :param 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 str dictionary_name: Dictionary name
-        :param str dictionary_value: Dictionary value
-        :param str id: UUID for condition
-        :param bool is_negate: Indicates whereas this condition is in negate mode
-        :param 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) -> 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[str]:
-        """
-        Dictionary attribute name
-        """
-        return pulumi.get(self, "attribute_name")
-
-    @property
-    @pulumi.getter(name="attributeValue")
-    def attribute_value(self) -> Optional[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[str]:
-        """
-        Dictionary name
-        """
-        return pulumi.get(self, "dictionary_name")
-
-    @property
-    @pulumi.getter(name="dictionaryValue")
-    def dictionary_value(self) -> Optional[str]:
-        """
-        Dictionary value
-        """
-        return pulumi.get(self, "dictionary_value")
-
-    @property
-    @pulumi.getter
-    def id(self) -> Optional[str]:
-        """
-        UUID for condition
-        """
-        return pulumi.get(self, "id")
-
-    @property
-    @pulumi.getter(name="isNegate")
-    def is_negate(self) -> Optional[bool]:
-        """
-        Indicates whereas this condition is in negate mode
-        """
-        return pulumi.get(self, "is_negate")
-
-    @property
-    @pulumi.getter
-    def operator(self) -> Optional[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: str,
-                 attribute_name: Optional[str] = None,
-                 attribute_value: Optional[str] = None,
-                 dictionary_name: Optional[str] = None,
-                 dictionary_value: Optional[str] = None,
-                 id: Optional[str] = None,
-                 is_negate: Optional[bool] = None,
-                 operator: Optional[str] = None):
-        """
-        :param str condition_type: Condition type.
-                 - Choices: `ConditionAttributes`, `ConditionReference`
-        :param str attribute_name: Dictionary attribute name
-        :param str attribute_value: Attribute value for condition. Value type is specified in dictionary object.
-        :param str dictionary_name: Dictionary name
-        :param str dictionary_value: Dictionary value
-        :param str id: UUID for condition
-        :param bool is_negate: Indicates whereas this condition is in negate mode
-        :param 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) -> str:
-        """
-        Condition type.
-          - Choices: `ConditionAttributes`, `ConditionReference`
-        """
-        return pulumi.get(self, "condition_type")
-
-    @property
-    @pulumi.getter(name="attributeName")
-    def attribute_name(self) -> Optional[str]:
-        """
-        Dictionary attribute name
-        """
-        return pulumi.get(self, "attribute_name")
-
-    @property
-    @pulumi.getter(name="attributeValue")
-    def attribute_value(self) -> Optional[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[str]:
-        """
-        Dictionary name
-        """
-        return pulumi.get(self, "dictionary_name")
-
-    @property
-    @pulumi.getter(name="dictionaryValue")
-    def dictionary_value(self) -> Optional[str]:
-        """
-        Dictionary value
-        """
-        return pulumi.get(self, "dictionary_value")
-
-    @property
-    @pulumi.getter
-    def id(self) -> Optional[str]:
-        """
-        UUID for condition
-        """
-        return pulumi.get(self, "id")
-
-    @property
-    @pulumi.getter(name="isNegate")
-    def is_negate(self) -> Optional[bool]:
-        """
-        Indicates whereas this condition is in negate mode
-        """
-        return pulumi.get(self, "is_negate")
-
-    @property
-    @pulumi.getter
-    def operator(self) -> Optional[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: str,
-                 attribute_name: Optional[str] = None,
-                 attribute_value: Optional[str] = None,
-                 childrens: Optional[Sequence['outputs.ConditionChildrenChildren']] = None,
-                 description: Optional[str] = None,
-                 dictionary_name: Optional[str] = None,
-                 dictionary_value: Optional[str] = None,
-                 id: Optional[str] = None,
-                 is_negate: Optional[bool] = None,
-                 name: Optional[str] = None,
-                 operator: Optional[str] = None):
-        """
-        :param 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 str attribute_name: Dictionary attribute name
-        :param 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 str description: Condition description
-        :param str dictionary_name: Dictionary name
-        :param str dictionary_value: Dictionary value
-        :param str id: UUID for condition
-        :param bool is_negate: Indicates whereas this condition is in negate mode
-        :param str name: Condition name
-        :param 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) -> 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[str]:
-        """
-        Dictionary attribute name
-        """
-        return pulumi.get(self, "attribute_name")
-
-    @property
-    @pulumi.getter(name="attributeValue")
-    def attribute_value(self) -> Optional[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[str]:
-        """
-        Condition description
-        """
-        return pulumi.get(self, "description")
-
-    @property
-    @pulumi.getter(name="dictionaryName")
-    def dictionary_name(self) -> Optional[str]:
-        """
-        Dictionary name
-        """
-        return pulumi.get(self, "dictionary_name")
-
-    @property
-    @pulumi.getter(name="dictionaryValue")
-    def dictionary_value(self) -> Optional[str]:
-        """
-        Dictionary value
-        """
-        return pulumi.get(self, "dictionary_value")
-
-    @property
-    @pulumi.getter
-    def id(self) -> Optional[str]:
-        """
-        UUID for condition
-        """
-        return pulumi.get(self, "id")
-
-    @property
-    @pulumi.getter(name="isNegate")
-    def is_negate(self) -> Optional[bool]:
-        """
-        Indicates whereas this condition is in negate mode
-        """
-        return pulumi.get(self, "is_negate")
-
-    @property
-    @pulumi.getter
-    def name(self) -> Optional[str]:
-        """
-        Condition name
-        """
-        return pulumi.get(self, "name")
-
-    @property
-    @pulumi.getter
-    def operator(self) -> Optional[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: str,
-                 attribute_name: Optional[str] = None,
-                 attribute_value: Optional[str] = None,
-                 description: Optional[str] = None,
-                 dictionary_name: Optional[str] = None,
-                 dictionary_value: Optional[str] = None,
-                 id: Optional[str] = None,
-                 is_negate: Optional[bool] = None,
-                 name: Optional[str] = None,
-                 operator: Optional[str] = None):
-        """
-        :param str condition_type: Condition type.
-                 - Choices: `ConditionAttributes`, `ConditionReference`
-        :param str attribute_name: Dictionary attribute name
-        :param str attribute_value: Attribute value for condition. Value type is specified in dictionary object.
-        :param str description: Condition description
-        :param str dictionary_name: Dictionary name
-        :param str dictionary_value: Dictionary value
-        :param str id: UUID for condition
-        :param bool is_negate: Indicates whereas this condition is in negate mode
-        :param str name: Condition name
-        :param 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) -> str:
-        """
-        Condition type.
-          - Choices: `ConditionAttributes`, `ConditionReference`
-        """
-        return pulumi.get(self, "condition_type")
-
-    @property
-    @pulumi.getter(name="attributeName")
-    def attribute_name(self) -> Optional[str]:
-        """
-        Dictionary attribute name
-        """
-        return pulumi.get(self, "attribute_name")
-
-    @property
-    @pulumi.getter(name="attributeValue")
-    def attribute_value(self) -> Optional[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[str]:
-        """
-        Condition description
-        """
-        return pulumi.get(self, "description")
-
-    @property
-    @pulumi.getter(name="dictionaryName")
-    def dictionary_name(self) -> Optional[str]:
-        """
-        Dictionary name
-        """
-        return pulumi.get(self, "dictionary_name")
-
-    @property
-    @pulumi.getter(name="dictionaryValue")
-    def dictionary_value(self) -> Optional[str]:
-        """
-        Dictionary value
-        """
-        return pulumi.get(self, "dictionary_value")
-
-    @property
-    @pulumi.getter
-    def id(self) -> Optional[str]:
-        """
-        UUID for condition
-        """
-        return pulumi.get(self, "id")
-
-    @property
-    @pulumi.getter(name="isNegate")
-    def is_negate(self) -> Optional[bool]:
-        """
-        Indicates whereas this condition is in negate mode
-        """
-        return pulumi.get(self, "is_negate")
-
-    @property
-    @pulumi.getter
-    def name(self) -> Optional[str]:
-        """
-        Condition name
-        """
-        return pulumi.get(self, "name")
-
-    @property
-    @pulumi.getter
-    def operator(self) -> Optional[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: str,
-                 attribute_name: Optional[str] = None,
-                 attribute_value: Optional[str] = None,
-                 childrens: Optional[Sequence['outputs.PolicySetChildrenChildren']] = None,
-                 dictionary_name: Optional[str] = None,
-                 dictionary_value: Optional[str] = None,
-                 id: Optional[str] = None,
-                 is_negate: Optional[bool] = None,
-                 operator: Optional[str] = None):
-        """
-        :param 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 str attribute_name: Dictionary attribute name
-        :param 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 str dictionary_name: Dictionary name
-        :param str dictionary_value: Dictionary value
-        :param str id: UUID for condition
-        :param bool is_negate: Indicates whereas this condition is in negate mode
-        :param 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) -> 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[str]:
-        """
-        Dictionary attribute name
-        """
-        return pulumi.get(self, "attribute_name")
-
-    @property
-    @pulumi.getter(name="attributeValue")
-    def attribute_value(self) -> Optional[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[str]:
-        """
-        Dictionary name
-        """
-        return pulumi.get(self, "dictionary_name")
-
-    @property
-    @pulumi.getter(name="dictionaryValue")
-    def dictionary_value(self) -> Optional[str]:
-        """
-        Dictionary value
-        """
-        return pulumi.get(self, "dictionary_value")
-
-    @property
-    @pulumi.getter
-    def id(self) -> Optional[str]:
-        """
-        UUID for condition
-        """
-        return pulumi.get(self, "id")
-
-    @property
-    @pulumi.getter(name="isNegate")
-    def is_negate(self) -> Optional[bool]:
-        """
-        Indicates whereas this condition is in negate mode
-        """
-        return pulumi.get(self, "is_negate")
-
-    @property
-    @pulumi.getter
-    def operator(self) -> Optional[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: str,
-                 attribute_name: Optional[str] = None,
-                 attribute_value: Optional[str] = None,
-                 dictionary_name: Optional[str] = None,
-                 dictionary_value: Optional[str] = None,
-                 id: Optional[str] = None,
-                 is_negate: Optional[bool] = None,
-                 operator: Optional[str] = None):
-        """
-        :param str condition_type: Condition type.
-                 - Choices: `ConditionAttributes`, `ConditionReference`
-        :param str attribute_name: Dictionary attribute name
-        :param str attribute_value: Attribute value for condition. Value type is specified in dictionary object.
-        :param str dictionary_name: Dictionary name
-        :param str dictionary_value: Dictionary value
-        :param str id: UUID for condition
-        :param bool is_negate: Indicates whereas this condition is in negate mode
-        :param 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) -> str:
-        """
-        Condition type.
-          - Choices: `ConditionAttributes`, `ConditionReference`
-        """
-        return pulumi.get(self, "condition_type")
-
-    @property
-    @pulumi.getter(name="attributeName")
-    def attribute_name(self) -> Optional[str]:
-        """
-        Dictionary attribute name
-        """
-        return pulumi.get(self, "attribute_name")
-
-    @property
-    @pulumi.getter(name="attributeValue")
-    def attribute_value(self) -> Optional[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[str]:
-        """
-        Dictionary name
-        """
-        return pulumi.get(self, "dictionary_name")
-
-    @property
-    @pulumi.getter(name="dictionaryValue")
-    def dictionary_value(self) -> Optional[str]:
-        """
-        Dictionary value
-        """
-        return pulumi.get(self, "dictionary_value")
-
-    @property
-    @pulumi.getter
-    def id(self) -> Optional[str]:
-        """
-        UUID for condition
-        """
-        return pulumi.get(self, "id")
-
-    @property
-    @pulumi.getter(name="isNegate")
-    def is_negate(self) -> Optional[bool]:
-        """
-        Indicates whereas this condition is in negate mode
-        """
-        return pulumi.get(self, "is_negate")
-
-    @property
-    @pulumi.getter
-    def operator(self) -> Optional[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 TacacsCommandSetCommand(dict):
-    def __init__(__self__, *,
-                 arguments: str,
-                 command: str,
-                 grant: str):
-        """
-        :param str arguments: Command arguments
-        :param str command: Command
-        :param str grant: Grant
-                 - Choices: `PERMIT`, `DENY`, `DENY_ALWAYS`
-        """
-        pulumi.set(__self__, "arguments", arguments)
-        pulumi.set(__self__, "command", command)
-        pulumi.set(__self__, "grant", grant)
-
-    @property
-    @pulumi.getter
-    def arguments(self) -> str:
-        """
-        Command arguments
-        """
-        return pulumi.get(self, "arguments")
-
-    @property
-    @pulumi.getter
-    def command(self) -> str:
-        """
-        Command
-        """
-        return pulumi.get(self, "command")
-
-    @property
-    @pulumi.getter
-    def grant(self) -> str:
-        """
-        Grant
-          - Choices: `PERMIT`, `DENY`, `DENY_ALWAYS`
-        """
-        return pulumi.get(self, "grant")
-
-
-@pulumi.output_type
-class TacacsProfileSessionAttribute(dict):
-    def __init__(__self__, *,
-                 name: str,
-                 type: str,
-                 value: str):
-        """
-        :param str name: Name
-        :param str type: Type
-                 - Choices: `MANDATORY`, `OPTIONAL`
-        :param str value: Value
-        """
-        pulumi.set(__self__, "name", name)
-        pulumi.set(__self__, "type", type)
-        pulumi.set(__self__, "value", value)
-
-    @property
-    @pulumi.getter
-    def name(self) -> str:
-        """
-        Name
-        """
-        return pulumi.get(self, "name")
-
-    @property
-    @pulumi.getter
-    def type(self) -> str:
-        """
-        Type
-          - Choices: `MANDATORY`, `OPTIONAL`
-        """
-        return pulumi.get(self, "type")
-
-    @property
-    @pulumi.getter
-    def value(self) -> str:
-        """
-        Value
-        """
-        return pulumi.get(self, "value")
-
-
-@pulumi.output_type
-class GetAuthenticationRuleChildrenResult(dict):
-    def __init__(__self__, *,
-                 attribute_name: str,
-                 attribute_value: str,
-                 childrens: Sequence['outputs.GetAuthenticationRuleChildrenChildrenResult'],
-                 condition_type: str,
-                 dictionary_name: str,
-                 dictionary_value: str,
-                 id: str,
-                 is_negate: bool,
-                 operator: str):
-        """
-        :param str attribute_name: Dictionary attribute name
-        :param 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 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 str dictionary_name: Dictionary name
-        :param str dictionary_value: Dictionary value
-        :param str id: UUID for condition
-        :param bool is_negate: Indicates whereas this condition is in negate mode
-        :param 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) -> str:
-        """
-        Dictionary attribute name
-        """
-        return pulumi.get(self, "attribute_name")
-
-    @property
-    @pulumi.getter(name="attributeValue")
-    def attribute_value(self) -> 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) -> 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) -> str:
-        """
-        Dictionary name
-        """
-        return pulumi.get(self, "dictionary_name")
-
-    @property
-    @pulumi.getter(name="dictionaryValue")
-    def dictionary_value(self) -> str:
-        """
-        Dictionary value
-        """
-        return pulumi.get(self, "dictionary_value")
-
-    @property
-    @pulumi.getter
-    def id(self) -> str:
-        """
-        UUID for condition
-        """
-        return pulumi.get(self, "id")
-
-    @property
-    @pulumi.getter(name="isNegate")
-    def is_negate(self) -> bool:
-        """
-        Indicates whereas this condition is in negate mode
-        """
-        return pulumi.get(self, "is_negate")
-
-    @property
-    @pulumi.getter
-    def operator(self) -> str:
-        """
-        Equality operator
-        """
-        return pulumi.get(self, "operator")
-
-
-@pulumi.output_type
-class GetAuthenticationRuleChildrenChildrenResult(dict):
-    def __init__(__self__, *,
-                 attribute_name: str,
-                 attribute_value: str,
-                 condition_type: str,
-                 dictionary_name: str,
-                 dictionary_value: str,
-                 id: str,
-                 is_negate: bool,
-                 operator: str):
-        """
-        :param str attribute_name: Dictionary attribute name
-        :param str attribute_value: Attribute value for condition. Value type is specified in dictionary object.
-        :param str condition_type: Condition type.
-        :param str dictionary_name: Dictionary name
-        :param str dictionary_value: Dictionary value
-        :param str id: UUID for condition
-        :param bool is_negate: Indicates whereas this condition is in negate mode
-        :param 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) -> str:
-        """
-        Dictionary attribute name
-        """
-        return pulumi.get(self, "attribute_name")
-
-    @property
-    @pulumi.getter(name="attributeValue")
-    def attribute_value(self) -> 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) -> str:
-        """
-        Condition type.
-        """
-        return pulumi.get(self, "condition_type")
-
-    @property
-    @pulumi.getter(name="dictionaryName")
-    def dictionary_name(self) -> str:
-        """
-        Dictionary name
-        """
-        return pulumi.get(self, "dictionary_name")
-
-    @property
-    @pulumi.getter(name="dictionaryValue")
-    def dictionary_value(self) -> str:
-        """
-        Dictionary value
-        """
-        return pulumi.get(self, "dictionary_value")
-
-    @property
-    @pulumi.getter
-    def id(self) -> str:
-        """
-        UUID for condition
-        """
-        return pulumi.get(self, "id")
-
-    @property
-    @pulumi.getter(name="isNegate")
-    def is_negate(self) -> bool:
-        """
-        Indicates whereas this condition is in negate mode
-        """
-        return pulumi.get(self, "is_negate")
-
-    @property
-    @pulumi.getter
-    def operator(self) -> str:
-        """
-        Equality operator
-        """
-        return pulumi.get(self, "operator")
-
-
-@pulumi.output_type
-class GetAuthorizationExceptionRuleChildrenResult(dict):
-    def __init__(__self__, *,
-                 attribute_name: str,
-                 attribute_value: str,
-                 childrens: Sequence['outputs.GetAuthorizationExceptionRuleChildrenChildrenResult'],
-                 condition_type: str,
-                 dictionary_name: str,
-                 dictionary_value: str,
-                 id: str,
-                 is_negate: bool,
-                 operator: str):
-        """
-        :param str attribute_name: Dictionary attribute name
-        :param 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 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 str dictionary_name: Dictionary name
-        :param str dictionary_value: Dictionary value
-        :param str id: UUID for condition
-        :param bool is_negate: Indicates whereas this condition is in negate mode
-        :param 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) -> str:
-        """
-        Dictionary attribute name
-        """
-        return pulumi.get(self, "attribute_name")
-
-    @property
-    @pulumi.getter(name="attributeValue")
-    def attribute_value(self) -> 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) -> 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) -> str:
-        """
-        Dictionary name
-        """
-        return pulumi.get(self, "dictionary_name")
-
-    @property
-    @pulumi.getter(name="dictionaryValue")
-    def dictionary_value(self) -> str:
-        """
-        Dictionary value
-        """
-        return pulumi.get(self, "dictionary_value")
-
-    @property
-    @pulumi.getter
-    def id(self) -> str:
-        """
-        UUID for condition
-        """
-        return pulumi.get(self, "id")
-
-    @property
-    @pulumi.getter(name="isNegate")
-    def is_negate(self) -> bool:
-        """
-        Indicates whereas this condition is in negate mode
-        """
-        return pulumi.get(self, "is_negate")
-
-    @property
-    @pulumi.getter
-    def operator(self) -> str:
-        """
-        Equality operator
-        """
-        return pulumi.get(self, "operator")
-
-
-@pulumi.output_type
-class GetAuthorizationExceptionRuleChildrenChildrenResult(dict):
-    def __init__(__self__, *,
-                 attribute_name: str,
-                 attribute_value: str,
-                 condition_type: str,
-                 dictionary_name: str,
-                 dictionary_value: str,
-                 id: str,
-                 is_negate: bool,
-                 operator: str):
-        """
-        :param str attribute_name: Dictionary attribute name
-        :param str attribute_value: Attribute value for condition. Value type is specified in dictionary object.
-        :param str condition_type: Condition type.
-        :param str dictionary_name: Dictionary name
-        :param str dictionary_value: Dictionary value
-        :param str id: UUID for condition
-        :param bool is_negate: Indicates whereas this condition is in negate mode
-        :param 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) -> str:
-        """
-        Dictionary attribute name
-        """
-        return pulumi.get(self, "attribute_name")
-
-    @property
-    @pulumi.getter(name="attributeValue")
-    def attribute_value(self) -> 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) -> str:
-        """
-        Condition type.
-        """
-        return pulumi.get(self, "condition_type")
-
-    @property
-    @pulumi.getter(name="dictionaryName")
-    def dictionary_name(self) -> str:
-        """
-        Dictionary name
-        """
-        return pulumi.get(self, "dictionary_name")
-
-    @property
-    @pulumi.getter(name="dictionaryValue")
-    def dictionary_value(self) -> str:
-        """
-        Dictionary value
-        """
-        return pulumi.get(self, "dictionary_value")
-
-    @property
-    @pulumi.getter
-    def id(self) -> str:
-        """
-        UUID for condition
-        """
-        return pulumi.get(self, "id")
-
-    @property
-    @pulumi.getter(name="isNegate")
-    def is_negate(self) -> bool:
-        """
-        Indicates whereas this condition is in negate mode
-        """
-        return pulumi.get(self, "is_negate")
-
-    @property
-    @pulumi.getter
-    def operator(self) -> str:
-        """
-        Equality operator
-        """
-        return pulumi.get(self, "operator")
-
-
-@pulumi.output_type
-class GetAuthorizationGlobalExceptionRuleChildrenResult(dict):
-    def __init__(__self__, *,
-                 attribute_name: str,
-                 attribute_value: str,
-                 childrens: Sequence['outputs.GetAuthorizationGlobalExceptionRuleChildrenChildrenResult'],
-                 condition_type: str,
-                 dictionary_name: str,
-                 dictionary_value: str,
-                 id: str,
-                 is_negate: bool,
-                 operator: str):
-        """
-        :param str attribute_name: Dictionary attribute name
-        :param 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 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 str dictionary_name: Dictionary name
-        :param str dictionary_value: Dictionary value
-        :param str id: UUID for condition
-        :param bool is_negate: Indicates whereas this condition is in negate mode
-        :param 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) -> str:
-        """
-        Dictionary attribute name
-        """
-        return pulumi.get(self, "attribute_name")
-
-    @property
-    @pulumi.getter(name="attributeValue")
-    def attribute_value(self) -> 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) -> 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) -> str:
-        """
-        Dictionary name
-        """
-        return pulumi.get(self, "dictionary_name")
-
-    @property
-    @pulumi.getter(name="dictionaryValue")
-    def dictionary_value(self) -> str:
-        """
-        Dictionary value
-        """
-        return pulumi.get(self, "dictionary_value")
-
-    @property
-    @pulumi.getter
-    def id(self) -> str:
-        """
-        UUID for condition
-        """
-        return pulumi.get(self, "id")
-
-    @property
-    @pulumi.getter(name="isNegate")
-    def is_negate(self) -> bool:
-        """
-        Indicates whereas this condition is in negate mode
-        """
-        return pulumi.get(self, "is_negate")
-
-    @property
-    @pulumi.getter
-    def operator(self) -> str:
-        """
-        Equality operator
-        """
-        return pulumi.get(self, "operator")
-
-
-@pulumi.output_type
-class GetAuthorizationGlobalExceptionRuleChildrenChildrenResult(dict):
-    def __init__(__self__, *,
-                 attribute_name: str,
-                 attribute_value: str,
-                 condition_type: str,
-                 dictionary_name: str,
-                 dictionary_value: str,
-                 id: str,
-                 is_negate: bool,
-                 operator: str):
-        """
-        :param str attribute_name: Dictionary attribute name
-        :param str attribute_value: Attribute value for condition. Value type is specified in dictionary object.
-        :param str condition_type: Condition type.
-        :param str dictionary_name: Dictionary name
-        :param str dictionary_value: Dictionary value
-        :param str id: UUID for condition
-        :param bool is_negate: Indicates whereas this condition is in negate mode
-        :param 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) -> str:
-        """
-        Dictionary attribute name
-        """
-        return pulumi.get(self, "attribute_name")
-
-    @property
-    @pulumi.getter(name="attributeValue")
-    def attribute_value(self) -> 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) -> str:
-        """
-        Condition type.
-        """
-        return pulumi.get(self, "condition_type")
-
-    @property
-    @pulumi.getter(name="dictionaryName")
-    def dictionary_name(self) -> str:
-        """
-        Dictionary name
-        """
-        return pulumi.get(self, "dictionary_name")
-
-    @property
-    @pulumi.getter(name="dictionaryValue")
-    def dictionary_value(self) -> str:
-        """
-        Dictionary value
-        """
-        return pulumi.get(self, "dictionary_value")
-
-    @property
-    @pulumi.getter
-    def id(self) -> str:
-        """
-        UUID for condition
-        """
-        return pulumi.get(self, "id")
-
-    @property
-    @pulumi.getter(name="isNegate")
-    def is_negate(self) -> bool:
-        """
-        Indicates whereas this condition is in negate mode
-        """
-        return pulumi.get(self, "is_negate")
-
-    @property
-    @pulumi.getter
-    def operator(self) -> str:
-        """
-        Equality operator
-        """
-        return pulumi.get(self, "operator")
-
-
-@pulumi.output_type
-class GetAuthorizationRuleChildrenResult(dict):
-    def __init__(__self__, *,
-                 attribute_name: str,
-                 attribute_value: str,
-                 childrens: Sequence['outputs.GetAuthorizationRuleChildrenChildrenResult'],
-                 condition_type: str,
-                 dictionary_name: str,
-                 dictionary_value: str,
-                 id: str,
-                 is_negate: bool,
-                 operator: str):
-        """
-        :param str attribute_name: Dictionary attribute name
-        :param 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 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 str dictionary_name: Dictionary name
-        :param str dictionary_value: Dictionary value
-        :param str id: UUID for condition
-        :param bool is_negate: Indicates whereas this condition is in negate mode
-        :param 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) -> str:
-        """
-        Dictionary attribute name
-        """
-        return pulumi.get(self, "attribute_name")
-
-    @property
-    @pulumi.getter(name="attributeValue")
-    def attribute_value(self) -> 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) -> 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) -> str:
-        """
-        Dictionary name
-        """
-        return pulumi.get(self, "dictionary_name")
-
-    @property
-    @pulumi.getter(name="dictionaryValue")
-    def dictionary_value(self) -> str:
-        """
-        Dictionary value
-        """
-        return pulumi.get(self, "dictionary_value")
-
-    @property
-    @pulumi.getter
-    def id(self) -> str:
-        """
-        UUID for condition
-        """
-        return pulumi.get(self, "id")
-
-    @property
-    @pulumi.getter(name="isNegate")
-    def is_negate(self) -> bool:
-        """
-        Indicates whereas this condition is in negate mode
-        """
-        return pulumi.get(self, "is_negate")
-
-    @property
-    @pulumi.getter
-    def operator(self) -> str:
-        """
-        Equality operator
-        """
-        return pulumi.get(self, "operator")
-
-
-@pulumi.output_type
-class GetAuthorizationRuleChildrenChildrenResult(dict):
-    def __init__(__self__, *,
-                 attribute_name: str,
-                 attribute_value: str,
-                 condition_type: str,
-                 dictionary_name: str,
-                 dictionary_value: str,
-                 id: str,
-                 is_negate: bool,
-                 operator: str):
-        """
-        :param str attribute_name: Dictionary attribute name
-        :param str attribute_value: Attribute value for condition. Value type is specified in dictionary object.
-        :param str condition_type: Condition type.
-        :param str dictionary_name: Dictionary name
-        :param str dictionary_value: Dictionary value
-        :param str id: UUID for condition
-        :param bool is_negate: Indicates whereas this condition is in negate mode
-        :param 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) -> str:
-        """
-        Dictionary attribute name
-        """
-        return pulumi.get(self, "attribute_name")
-
-    @property
-    @pulumi.getter(name="attributeValue")
-    def attribute_value(self) -> 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) -> str:
-        """
-        Condition type.
-        """
-        return pulumi.get(self, "condition_type")
-
-    @property
-    @pulumi.getter(name="dictionaryName")
-    def dictionary_name(self) -> str:
-        """
-        Dictionary name
-        """
-        return pulumi.get(self, "dictionary_name")
-
-    @property
-    @pulumi.getter(name="dictionaryValue")
-    def dictionary_value(self) -> str:
-        """
-        Dictionary value
-        """
-        return pulumi.get(self, "dictionary_value")
-
-    @property
-    @pulumi.getter
-    def id(self) -> str:
-        """
-        UUID for condition
-        """
-        return pulumi.get(self, "id")
-
-    @property
-    @pulumi.getter(name="isNegate")
-    def is_negate(self) -> bool:
-        """
-        Indicates whereas this condition is in negate mode
-        """
-        return pulumi.get(self, "is_negate")
-
-    @property
-    @pulumi.getter
-    def operator(self) -> str:
-        """
-        Equality operator
-        """
-        return pulumi.get(self, "operator")
-
-
-@pulumi.output_type
-class GetConditionChildrenResult(dict):
-    def __init__(__self__, *,
-                 attribute_name: str,
-                 attribute_value: str,
-                 childrens: Sequence['outputs.GetConditionChildrenChildrenResult'],
-                 condition_type: str,
-                 description: str,
-                 dictionary_name: str,
-                 dictionary_value: str,
-                 id: str,
-                 is_negate: bool,
-                 name: str,
-                 operator: str):
+    def condition_type(self) -> str:
         """
-        :param str attribute_name: Dictionary attribute name
-        :param 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 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 str description: Condition description
-        :param str dictionary_name: Dictionary name
-        :param str dictionary_value: Dictionary value
-        :param str id: UUID for condition
-        :param bool is_negate: Indicates whereas this condition is in negate mode
-        :param str name: Condition name
-        :param str operator: Equality operator
+        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`
         """
-        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)
+        return pulumi.get(self, "condition_type")
 
     @property
     @pulumi.getter(name="attributeName")
-    def attribute_name(self) -> str:
+    def attribute_name(self) -> Optional[str]:
         """
         Dictionary attribute name
         """
@@ -2694,7 +114,7 @@ class GetConditionChildrenResult(dict):
 
     @property
     @pulumi.getter(name="attributeValue")
-    def attribute_value(self) -> str:
+    def attribute_value(self) -> Optional[str]:
         """
         Attribute value for condition. Value type is specified in dictionary object.
         """
@@ -2702,23 +122,15 @@ class GetConditionChildrenResult(dict):
 
     @property
     @pulumi.getter
-    def childrens(self) -> Sequence['outputs.GetConditionChildrenChildrenResult']:
+    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(name="conditionType")
-    def condition_type(self) -> 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) -> str:
+    def description(self) -> Optional[str]:
         """
         Condition description
         """
@@ -2726,7 +138,7 @@ class GetConditionChildrenResult(dict):
 
     @property
     @pulumi.getter(name="dictionaryName")
-    def dictionary_name(self) -> str:
+    def dictionary_name(self) -> Optional[str]:
         """
         Dictionary name
         """
@@ -2734,7 +146,7 @@ class GetConditionChildrenResult(dict):
 
     @property
     @pulumi.getter(name="dictionaryValue")
-    def dictionary_value(self) -> str:
+    def dictionary_value(self) -> Optional[str]:
         """
         Dictionary value
         """
@@ -2742,7 +154,7 @@ class GetConditionChildrenResult(dict):
 
     @property
     @pulumi.getter
-    def id(self) -> str:
+    def id(self) -> Optional[str]:
         """
         UUID for condition
         """
@@ -2750,7 +162,7 @@ class GetConditionChildrenResult(dict):
 
     @property
     @pulumi.getter(name="isNegate")
-    def is_negate(self) -> bool:
+    def is_negate(self) -> Optional[bool]:
         """
         Indicates whereas this condition is in negate mode
         """
@@ -2758,7 +170,7 @@ class GetConditionChildrenResult(dict):
 
     @property
     @pulumi.getter
-    def name(self) -> str:
+    def name(self) -> Optional[str]:
         """
         Condition name
         """
@@ -2766,30 +178,59 @@ class GetConditionChildrenResult(dict):
 
     @property
     @pulumi.getter
-    def operator(self) -> str:
+    def operator(self) -> Optional[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 GetConditionChildrenChildrenResult(dict):
+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__, *,
-                 attribute_name: str,
-                 attribute_value: str,
                  condition_type: str,
-                 description: str,
-                 dictionary_name: str,
-                 dictionary_value: str,
-                 id: str,
-                 is_negate: bool,
-                 name: str,
-                 operator: str):
+                 attribute_name: Optional[str] = None,
+                 attribute_value: Optional[str] = None,
+                 description: Optional[str] = None,
+                 dictionary_name: Optional[str] = None,
+                 dictionary_value: Optional[str] = None,
+                 id: Optional[str] = None,
+                 is_negate: Optional[bool] = None,
+                 name: Optional[str] = None,
+                 operator: Optional[str] = None):
         """
+        :param str condition_type: Condition type.
+                 - Choices: `ConditionAttributes`, `ConditionReference`
         :param str attribute_name: Dictionary attribute name
         :param str attribute_value: Attribute value for condition. Value type is specified in dictionary object.
-        :param str condition_type: Condition type.
         :param str description: Condition description
         :param str dictionary_name: Dictionary name
         :param str dictionary_value: Dictionary value
@@ -2797,21 +238,40 @@ class GetConditionChildrenChildrenResult(dict):
         :param bool is_negate: Indicates whereas this condition is in negate mode
         :param str name: Condition name
         :param 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__, "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)
+        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) -> str:
+        """
+        Condition type.
+          - Choices: `ConditionAttributes`, `ConditionReference`
+        """
+        return pulumi.get(self, "condition_type")
 
     @property
     @pulumi.getter(name="attributeName")
-    def attribute_name(self) -> str:
+    def attribute_name(self) -> Optional[str]:
         """
         Dictionary attribute name
         """
@@ -2819,23 +279,15 @@ class GetConditionChildrenChildrenResult(dict):
 
     @property
     @pulumi.getter(name="attributeValue")
-    def attribute_value(self) -> str:
+    def attribute_value(self) -> Optional[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) -> str:
-        """
-        Condition type.
-        """
-        return pulumi.get(self, "condition_type")
-
     @property
     @pulumi.getter
-    def description(self) -> str:
+    def description(self) -> Optional[str]:
         """
         Condition description
         """
@@ -2843,7 +295,7 @@ class GetConditionChildrenChildrenResult(dict):
 
     @property
     @pulumi.getter(name="dictionaryName")
-    def dictionary_name(self) -> str:
+    def dictionary_name(self) -> Optional[str]:
         """
         Dictionary name
         """
@@ -2851,7 +303,7 @@ class GetConditionChildrenChildrenResult(dict):
 
     @property
     @pulumi.getter(name="dictionaryValue")
-    def dictionary_value(self) -> str:
+    def dictionary_value(self) -> Optional[str]:
         """
         Dictionary value
         """
@@ -2859,7 +311,7 @@ class GetConditionChildrenChildrenResult(dict):
 
     @property
     @pulumi.getter
-    def id(self) -> str:
+    def id(self) -> Optional[str]:
         """
         UUID for condition
         """
@@ -2867,7 +319,7 @@ class GetConditionChildrenChildrenResult(dict):
 
     @property
     @pulumi.getter(name="isNegate")
-    def is_negate(self) -> bool:
+    def is_negate(self) -> Optional[bool]:
         """
         Indicates whereas this condition is in negate mode
         """
@@ -2875,7 +327,7 @@ class GetConditionChildrenChildrenResult(dict):
 
     @property
     @pulumi.getter
-    def name(self) -> str:
+    def name(self) -> Optional[str]:
         """
         Condition name
         """
@@ -2883,44 +335,51 @@ class GetConditionChildrenChildrenResult(dict):
 
     @property
     @pulumi.getter
-    def operator(self) -> str:
+    def operator(self) -> Optional[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 GetPolicySetChildrenResult(dict):
+class GetConditionChildrenResult(dict):
     def __init__(__self__, *,
                  attribute_name: str,
                  attribute_value: str,
-                 childrens: Sequence['outputs.GetPolicySetChildrenChildrenResult'],
+                 childrens: Sequence['outputs.GetConditionChildrenChildrenResult'],
                  condition_type: str,
+                 description: str,
                  dictionary_name: str,
                  dictionary_value: str,
                  id: str,
                  is_negate: bool,
+                 name: str,
                  operator: str):
         """
         :param str attribute_name: Dictionary attribute name
         :param 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 Sequence['GetConditionChildrenChildrenArgs'] childrens: List of child conditions. `condition_type` must be one of `ConditionAndBlock` or `ConditionOrBlock`.
         :param 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 str description: Condition description
         :param str dictionary_name: Dictionary name
         :param str dictionary_value: Dictionary value
         :param str id: UUID for condition
         :param bool is_negate: Indicates whereas this condition is in negate mode
+        :param str name: Condition name
         :param 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
@@ -2941,7 +400,7 @@ class GetPolicySetChildrenResult(dict):
 
     @property
     @pulumi.getter
-    def childrens(self) -> Sequence['outputs.GetPolicySetChildrenChildrenResult']:
+    def childrens(self) -> Sequence['outputs.GetConditionChildrenChildrenResult']:
         """
         List of child conditions. `condition_type` must be one of `ConditionAndBlock` or `ConditionOrBlock`.
         """
@@ -2955,6 +414,14 @@ class GetPolicySetChildrenResult(dict):
         """
         return pulumi.get(self, "condition_type")
 
+    @property
+    @pulumi.getter
+    def description(self) -> str:
+        """
+        Condition description
+        """
+        return pulumi.get(self, "description")
+
     @property
     @pulumi.getter(name="dictionaryName")
     def dictionary_name(self) -> str:
@@ -2987,6 +454,14 @@ class GetPolicySetChildrenResult(dict):
         """
         return pulumi.get(self, "is_negate")
 
+    @property
+    @pulumi.getter
+    def name(self) -> str:
+        """
+        Condition name
+        """
+        return pulumi.get(self, "name")
+
     @property
     @pulumi.getter
     def operator(self) -> str:
@@ -2997,33 +472,39 @@ class GetPolicySetChildrenResult(dict):
 
 
 @pulumi.output_type
-class GetPolicySetChildrenChildrenResult(dict):
+class GetConditionChildrenChildrenResult(dict):
     def __init__(__self__, *,
                  attribute_name: str,
                  attribute_value: str,
                  condition_type: str,
+                 description: str,
                  dictionary_name: str,
                  dictionary_value: str,
                  id: str,
                  is_negate: bool,
+                 name: str,
                  operator: str):
         """
         :param str attribute_name: Dictionary attribute name
         :param str attribute_value: Attribute value for condition. Value type is specified in dictionary object.
         :param str condition_type: Condition type.
+        :param str description: Condition description
         :param str dictionary_name: Dictionary name
         :param str dictionary_value: Dictionary value
         :param str id: UUID for condition
         :param bool is_negate: Indicates whereas this condition is in negate mode
+        :param str name: Condition name
         :param 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
@@ -3050,6 +531,14 @@ class GetPolicySetChildrenChildrenResult(dict):
         """
         return pulumi.get(self, "condition_type")
 
+    @property
+    @pulumi.getter
+    def description(self) -> str:
+        """
+        Condition description
+        """
+        return pulumi.get(self, "description")
+
     @property
     @pulumi.getter(name="dictionaryName")
     def dictionary_name(self) -> str:
@@ -3082,92 +571,20 @@ class GetPolicySetChildrenChildrenResult(dict):
         """
         return pulumi.get(self, "is_negate")
 
-    @property
-    @pulumi.getter
-    def operator(self) -> str:
-        """
-        Equality operator
-        """
-        return pulumi.get(self, "operator")
-
-
-@pulumi.output_type
-class GetTacacsCommandSetCommandResult(dict):
-    def __init__(__self__, *,
-                 arguments: str,
-                 command: str,
-                 grant: str):
-        """
-        :param str arguments: Command arguments
-        :param str command: Command
-        :param str grant: Grant
-        """
-        pulumi.set(__self__, "arguments", arguments)
-        pulumi.set(__self__, "command", command)
-        pulumi.set(__self__, "grant", grant)
-
-    @property
-    @pulumi.getter
-    def arguments(self) -> str:
-        """
-        Command arguments
-        """
-        return pulumi.get(self, "arguments")
-
-    @property
-    @pulumi.getter
-    def command(self) -> str:
-        """
-        Command
-        """
-        return pulumi.get(self, "command")
-
-    @property
-    @pulumi.getter
-    def grant(self) -> str:
-        """
-        Grant
-        """
-        return pulumi.get(self, "grant")
-
-
-@pulumi.output_type
-class GetTacacsProfileSessionAttributeResult(dict):
-    def __init__(__self__, *,
-                 name: str,
-                 type: str,
-                 value: str):
-        """
-        :param str name: Name
-        :param str type: Type
-        :param str value: Value
-        """
-        pulumi.set(__self__, "name", name)
-        pulumi.set(__self__, "type", type)
-        pulumi.set(__self__, "value", value)
-
     @property
     @pulumi.getter
     def name(self) -> str:
         """
-        Name
+        Condition name
         """
         return pulumi.get(self, "name")
 
     @property
     @pulumi.getter
-    def type(self) -> str:
-        """
-        Type
-        """
-        return pulumi.get(self, "type")
-
-    @property
-    @pulumi.getter
-    def value(self) -> str:
+    def operator(self) -> str:
         """
-        Value
+        Equality operator
         """
-        return pulumi.get(self, "value")
+        return pulumi.get(self, "operator")