acryl-datahub-cloud 0.3.13rc2__py3-none-any.whl → 0.3.13rc4__py3-none-any.whl

acryl_datahub_cloud/metadata/schema_classes.py

@@ -767,7 +767,7 @@ class ActionRequestInfoClass(_Aspect):
     
     @property
     def type(self) -> str:
-        """The type of the action request, for example 'TAG_ASSOCIATION'"""
+        """The type of the action request, for example 'TAG_ASSOCIATION', 'WORKFLOW_FORM_REQUEST'"""
         return self._inner_dict.get('type')  # type: ignore
     
     @type.setter
@@ -948,6 +948,7 @@ class ActionRequestParamsClass(DictWrapper):
         createGlossaryNodeProposal: Union[None, "CreateGlossaryNodeProposalClass"]=None,
         updateDescriptionProposal: Union[None, "DescriptionProposalClass"]=None,
         dataContractProposal: Union[None, "DataContractProposalClass"]=None,
+        workflowFormRequest: Union[None, "ActionWorkflowFormRequestClass"]=None,
     ):
         super().__init__()
         
@@ -960,6 +961,7 @@ class ActionRequestParamsClass(DictWrapper):
         self.createGlossaryNodeProposal = createGlossaryNodeProposal
         self.updateDescriptionProposal = updateDescriptionProposal
         self.dataContractProposal = dataContractProposal
+        self.workflowFormRequest = workflowFormRequest
     
     def _restore_defaults(self) -> None:
         self.glossaryTermProposal = self.RECORD_SCHEMA.fields_dict["glossaryTermProposal"].default
@@ -971,6 +973,7 @@ class ActionRequestParamsClass(DictWrapper):
         self.createGlossaryNodeProposal = self.RECORD_SCHEMA.fields_dict["createGlossaryNodeProposal"].default
         self.updateDescriptionProposal = self.RECORD_SCHEMA.fields_dict["updateDescriptionProposal"].default
         self.dataContractProposal = self.RECORD_SCHEMA.fields_dict["dataContractProposal"].default
+        self.workflowFormRequest = self.RECORD_SCHEMA.fields_dict["workflowFormRequest"].default
     
     
     @property
@@ -1065,6 +1068,16 @@ class ActionRequestParamsClass(DictWrapper):
         self._inner_dict['dataContractProposal'] = value
     
     
+    @property
+    def workflowFormRequest(self) -> Union[None, "ActionWorkflowFormRequestClass"]:
+        """An action workflow form request."""
+        return self._inner_dict.get('workflowFormRequest')  # type: ignore
+    
+    @workflowFormRequest.setter
+    def workflowFormRequest(self, value: Union[None, "ActionWorkflowFormRequestClass"]) -> None:
+        self._inner_dict['workflowFormRequest'] = value
+    
+    
 class ActionRequestStatusClass(_Aspect):
     """The status of the action request - e.g. accepted, rejected, pending, etc"""
 
@@ -1498,6 +1511,985 @@ class TagProposalClass(DictWrapper):
         self._inner_dict['tags'] = value
     
     
+class ActionWorkflowCategoryClass(object):
+    # No docs available.
+    
+    ACCESS = "ACCESS"
+    """Workflow for requesting access to a resource, such as a dataset or data job.
+    Requires the `access` field to be populated with specific access parameters."""
+    
+    CUSTOM = "CUSTOM"
+    """Custom, non-access related workflow. For example, may be used to model workflows like
+    asset creation, asset cleanup or deletion, etc."""
+    
+    
+    
+class ActionWorkflowEntrypointClass(DictWrapper):
+    """The entry point arguments for the action request workflowform.
+    In the future, we may extend this model to support more granular entry point filters."""
+    
+    RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.actionworkflow.ActionWorkflowEntrypoint")
+    def __init__(self,
+        type: Union[str, "ActionWorkflowEntrypointTypeClass"],
+        label: str,
+        filter: Union[None, "FilterClass"]=None,
+    ):
+        super().__init__()
+        
+        self.type = type
+        self.label = label
+        self.filter = filter
+    
+    def _restore_defaults(self) -> None:
+        self.type = ActionWorkflowEntrypointTypeClass.HOME
+        self.label = str()
+        self.filter = self.RECORD_SCHEMA.fields_dict["filter"].default
+    
+    
+    @property
+    def type(self) -> Union[str, "ActionWorkflowEntrypointTypeClass"]:
+        """The type of entry point for the action request workflow.
+    This determines where the action request workflow will be displayed."""
+        return self._inner_dict.get('type')  # type: ignore
+    
+    @type.setter
+    def type(self, value: Union[str, "ActionWorkflowEntrypointTypeClass"]) -> None:
+        self._inner_dict['type'] = value
+    
+    
+    @property
+    def label(self) -> str:
+        """The label for the entry point, which is displayed to users.
+    This should be a user-friendly name that describes the action request."""
+        return self._inner_dict.get('label')  # type: ignore
+    
+    @label.setter
+    def label(self, value: str) -> None:
+        self._inner_dict['label'] = value
+    
+    
+    @property
+    def filter(self) -> Union[None, "FilterClass"]:
+        """Additional filter criteria to determine when the entry point should be displayed.
+    
+    Not yet supported (but will be in the future)."""
+        return self._inner_dict.get('filter')  # type: ignore
+    
+    @filter.setter
+    def filter(self, value: Union[None, "FilterClass"]) -> None:
+        self._inner_dict['filter'] = value
+    
+    
+class ActionWorkflowEntrypointTypeClass(object):
+    # No docs available.
+    
+    HOME = "HOME"
+    """ Visible on the home page to all users. """
+    
+    ENTITY_PROFILE = "ENTITY_PROFILE"
+    """ Visible on the entity profile page. For all valid entity types specified in the parent object. """
+    
+    
+    
+class ActionWorkflowFieldClass(DictWrapper):
+    """A field inside an Action Workflow Form."""
+    
+    RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.actionworkflow.ActionWorkflowField")
+    def __init__(self,
+        id: str,
+        name: str,
+        valueType: str,
+        cardinality: Union[str, "PropertyCardinalityClass"],
+        description: Union[None, str]=None,
+        allowedEntityTypes: Union[None, List[str]]=None,
+        allowedValues: Union[None, List["PropertyValueClass"]]=None,
+        required: Optional[bool]=None,
+        condition: Union[None, "ActionWorkflowFieldConditionClass"]=None,
+    ):
+        super().__init__()
+        
+        self.id = id
+        self.name = name
+        self.description = description
+        self.valueType = valueType
+        self.allowedEntityTypes = allowedEntityTypes
+        self.allowedValues = allowedValues
+        self.cardinality = cardinality
+        if required is None:
+            # default: False
+            self.required = self.RECORD_SCHEMA.fields_dict["required"].default
+        else:
+            self.required = required
+        self.condition = condition
+    
+    def _restore_defaults(self) -> None:
+        self.id = str()
+        self.name = str()
+        self.description = self.RECORD_SCHEMA.fields_dict["description"].default
+        self.valueType = str()
+        self.allowedEntityTypes = self.RECORD_SCHEMA.fields_dict["allowedEntityTypes"].default
+        self.allowedValues = self.RECORD_SCHEMA.fields_dict["allowedValues"].default
+        self.cardinality = PropertyCardinalityClass.SINGLE
+        self.required = self.RECORD_SCHEMA.fields_dict["required"].default
+        self.condition = self.RECORD_SCHEMA.fields_dict["condition"].default
+    
+    
+    @property
+    def id(self) -> str:
+        """Workflow-local id for the field"""
+        return self._inner_dict.get('id')  # type: ignore
+    
+    @id.setter
+    def id(self, value: str) -> None:
+        self._inner_dict['id'] = value
+    
+    
+    @property
+    def name(self) -> str:
+        """The display name or label for the field, for rendering"""
+        return self._inner_dict.get('name')  # type: ignore
+    
+    @name.setter
+    def name(self, value: str) -> None:
+        self._inner_dict['name'] = value
+    
+    
+    @property
+    def description(self) -> Union[None, str]:
+        """The description for the field, for rendering"""
+        return self._inner_dict.get('description')  # type: ignore
+    
+    @description.setter
+    def description(self, value: Union[None, str]) -> None:
+        self._inner_dict['description'] = value
+    
+    
+    @property
+    def valueType(self) -> str:
+        """The urn of the value type for the values - reused from structured properties.
+    Also, used for rendering"""
+        return self._inner_dict.get('valueType')  # type: ignore
+    
+    @valueType.setter
+    def valueType(self, value: str) -> None:
+        self._inner_dict['valueType'] = value
+    
+    
+    @property
+    def allowedEntityTypes(self) -> Union[None, List[str]]:
+        """The urns for allowed entity types."""
+        return self._inner_dict.get('allowedEntityTypes')  # type: ignore
+    
+    @allowedEntityTypes.setter
+    def allowedEntityTypes(self, value: Union[None, List[str]]) -> None:
+        self._inner_dict['allowedEntityTypes'] = value
+    
+    
+    @property
+    def allowedValues(self) -> Union[None, List["PropertyValueClass"]]:
+        """A list of allowed values that the property is allowed to take.
+    If this is not specified, then the property can take any value of given type."""
+        return self._inner_dict.get('allowedValues')  # type: ignore
+    
+    @allowedValues.setter
+    def allowedValues(self, value: Union[None, List["PropertyValueClass"]]) -> None:
+        self._inner_dict['allowedValues'] = value
+    
+    
+    @property
+    def cardinality(self) -> Union[str, "PropertyCardinalityClass"]:
+        """Whether or not multiple values are allowed."""
+        return self._inner_dict.get('cardinality')  # type: ignore
+    
+    @cardinality.setter
+    def cardinality(self, value: Union[str, "PropertyCardinalityClass"]) -> None:
+        self._inner_dict['cardinality'] = value
+    
+    
+    @property
+    def required(self) -> bool:
+        """Whether the field is required or not."""
+        return self._inner_dict.get('required')  # type: ignore
+    
+    @required.setter
+    def required(self, value: bool) -> None:
+        self._inner_dict['required'] = value
+    
+    
+    @property
+    def condition(self) -> Union[None, "ActionWorkflowFieldConditionClass"]:
+        """A dynamic condition that determines whether the field should be shown or not."""
+        return self._inner_dict.get('condition')  # type: ignore
+    
+    @condition.setter
+    def condition(self, value: Union[None, "ActionWorkflowFieldConditionClass"]) -> None:
+        self._inner_dict['condition'] = value
+    
+    
+class ActionWorkflowFieldConditionClass(DictWrapper):
+    """A condition that determines whether a form field should be shown in the action workflow.
+    This may evolve in the future to have additional condition types."""
+    
+    RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.actionworkflow.ActionWorkflowFieldCondition")
+    def __init__(self,
+        type: Union[str, "ActionWorkflowFieldConditionTypeClass"],
+        singleFieldValueCondition: Union[None, "ActionWorkflowSingleFieldValueConditionClass"]=None,
+    ):
+        super().__init__()
+        
+        self.type = type
+        self.singleFieldValueCondition = singleFieldValueCondition
+    
+    def _restore_defaults(self) -> None:
+        self.type = ActionWorkflowFieldConditionTypeClass.SINGLE_FIELD_VALUE
+        self.singleFieldValueCondition = self.RECORD_SCHEMA.fields_dict["singleFieldValueCondition"].default
+    
+    
+    @property
+    def type(self) -> Union[str, "ActionWorkflowFieldConditionTypeClass"]:
+        """The type of field condition"""
+        return self._inner_dict.get('type')  # type: ignore
+    
+    @type.setter
+    def type(self, value: Union[str, "ActionWorkflowFieldConditionTypeClass"]) -> None:
+        self._inner_dict['type'] = value
+    
+    
+    @property
+    def singleFieldValueCondition(self) -> Union[None, "ActionWorkflowSingleFieldValueConditionClass"]:
+        """A field value condition. Present if type is FIELD_VALUE."""
+        return self._inner_dict.get('singleFieldValueCondition')  # type: ignore
+    
+    @singleFieldValueCondition.setter
+    def singleFieldValueCondition(self, value: Union[None, "ActionWorkflowSingleFieldValueConditionClass"]) -> None:
+        self._inner_dict['singleFieldValueCondition'] = value
+    
+    
+class ActionWorkflowFieldConditionTypeClass(object):
+    # No docs available.
+    
+    SINGLE_FIELD_VALUE = "SINGLE_FIELD_VALUE"
+    """The field should be shown if the value of a previously completed field matches the specified value."""
+    
+    
+    
+class ActionWorkflowFormClass(DictWrapper):
+    # No docs available.
+    
+    RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.actionworkflow.ActionWorkflowForm")
+    def __init__(self,
+        entrypoints: List["ActionWorkflowEntrypointClass"],
+        fields: List["ActionWorkflowFieldClass"],
+        entityTypes: Union[None, List[str]]=None,
+    ):
+        super().__init__()
+        
+        self.entrypoints = entrypoints
+        self.entityTypes = entityTypes
+        self.fields = fields
+    
+    def _restore_defaults(self) -> None:
+        self.entrypoints = list()
+        self.entityTypes = self.RECORD_SCHEMA.fields_dict["entityTypes"].default
+        self.fields = list()
+    
+    
+    @property
+    def entrypoints(self) -> List["ActionWorkflowEntrypointClass"]:
+        """Entrypoints for form submission."""
+        return self._inner_dict.get('entrypoints')  # type: ignore
+    
+    @entrypoints.setter
+    def entrypoints(self, value: List["ActionWorkflowEntrypointClass"]) -> None:
+        self._inner_dict['entrypoints'] = value
+    
+    
+    @property
+    def entityTypes(self) -> Union[None, List[str]]:
+        """The valid entity type URNs that can be associated with a Workflow Form.
+    If provided, this will require that an entity of one of the provided types is specified when completing the form.
+    
+    If no entity types are provided, the workflow form can be submitted without specifying an entity. In general, this should
+    be populated for workflows of type ACCESS to enable users to request access to a specific entity!
+    
+    If specified, the associated action requests for this workflow will contain an URN of the corresponding type inside of
+    the `resource` field.
+    
+    Note that associating multiple entities with a single Action Request is not yet supported."""
+        return self._inner_dict.get('entityTypes')  # type: ignore
+    
+    @entityTypes.setter
+    def entityTypes(self, value: Union[None, List[str]]) -> None:
+        self._inner_dict['entityTypes'] = value
+    
+    
+    @property
+    def fields(self) -> List["ActionWorkflowFieldClass"]:
+        """Fields comprising the workflow request. These are the inputs / arguments required to trigger the workflow."""
+        return self._inner_dict.get('fields')  # type: ignore
+    
+    @fields.setter
+    def fields(self, value: List["ActionWorkflowFieldClass"]) -> None:
+        self._inner_dict['fields'] = value
+    
+    
+class ActionWorkflowFormRequestClass(DictWrapper):
+    """A request for an access workflow form to be reviewed.
+    
+    For an access workflow of trigger type FORM, this action request currently represents the "state" 
+    of the workflow instance. 
+    
+    In the future, we may add more features like due dates, escalations, etc.
+    Ideally, for now we are keeping these out of here."""
+    
+    RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.actionworkflow.ActionWorkflowFormRequest")
+    def __init__(self,
+        workflow: str,
+        category: Union[str, "ActionWorkflowCategoryClass"],
+        fields: List["ActionWorkflowFormRequestFieldClass"],
+        stepState: "ActionWorkflowRequestStepStateClass",
+        customCategory: Union[None, str]=None,
+        access: Union[None, "ActionWorkflowRequestAccessClass"]=None,
+    ):
+        super().__init__()
+        
+        self.workflow = workflow
+        self.category = category
+        self.customCategory = customCategory
+        self.fields = fields
+        self.access = access
+        self.stepState = stepState
+    
+    def _restore_defaults(self) -> None:
+        self.workflow = str()
+        self.category = ActionWorkflowCategoryClass.ACCESS
+        self.customCategory = self.RECORD_SCHEMA.fields_dict["customCategory"].default
+        self.fields = list()
+        self.access = self.RECORD_SCHEMA.fields_dict["access"].default
+        self.stepState = ActionWorkflowRequestStepStateClass._construct_with_defaults()
+    
+    
+    @property
+    def workflow(self) -> str:
+        """The urn of the associated access request workflow."""
+        return self._inner_dict.get('workflow')  # type: ignore
+    
+    @workflow.setter
+    def workflow(self, value: str) -> None:
+        self._inner_dict['workflow'] = value
+    
+    
+    @property
+    def category(self) -> Union[str, "ActionWorkflowCategoryClass"]:
+        """The category of the workflow. 
+    Primarily used for searching / filtering action requests."""
+        return self._inner_dict.get('category')  # type: ignore
+    
+    @category.setter
+    def category(self, value: Union[str, "ActionWorkflowCategoryClass"]) -> None:
+        self._inner_dict['category'] = value
+    
+    
+    @property
+    def customCategory(self) -> Union[None, str]:
+        """The custom category of the workflow, if category is custom.
+    Primarily used for searching / filtering action requests."""
+        return self._inner_dict.get('customCategory')  # type: ignore
+    
+    @customCategory.setter
+    def customCategory(self, value: Union[None, str]) -> None:
+        self._inner_dict['customCategory'] = value
+    
+    
+    @property
+    def fields(self) -> List["ActionWorkflowFormRequestFieldClass"]:
+        """Custom fields provided by the user making the request if the action request is of type FORM_SUBMITTED
+    Eventually, these may need to become search indexed. For now, not indexed."""
+        return self._inner_dict.get('fields')  # type: ignore
+    
+    @fields.setter
+    def fields(self, value: List["ActionWorkflowFormRequestFieldClass"]) -> None:
+        self._inner_dict['fields'] = value
+    
+    
+    @property
+    def access(self) -> Union[None, "ActionWorkflowRequestAccessClass"]:
+        """Details specific for access request workflow requests."""
+        return self._inner_dict.get('access')  # type: ignore
+    
+    @access.setter
+    def access(self, value: Union[None, "ActionWorkflowRequestAccessClass"]) -> None:
+        self._inner_dict['access'] = value
+    
+    
+    @property
+    def stepState(self) -> "ActionWorkflowRequestStepStateClass":
+        """State related to steps. This should correspond to a step of type ACTION_REQUEST_REVIEW in the workflow 
+    definition."""
+        return self._inner_dict.get('stepState')  # type: ignore
+    
+    @stepState.setter
+    def stepState(self, value: "ActionWorkflowRequestStepStateClass") -> None:
+        self._inner_dict['stepState'] = value
+    
+    
+class ActionWorkflowFormRequestFieldClass(DictWrapper):
+    """Simply capture the field id + the value."""
+    
+    RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.actionworkflow.ActionWorkflowFormRequestField")
+    def __init__(self,
+        id: str,
+        values: List[Union[str, float]],
+    ):
+        super().__init__()
+        
+        self.id = id
+        self.values = values
+    
+    def _restore_defaults(self) -> None:
+        self.id = str()
+        self.values = list()
+    
+    
+    @property
+    def id(self) -> str:
+        """Workflow-local id for the field"""
+        return self._inner_dict.get('id')  # type: ignore
+    
+    @id.setter
+    def id(self, value: str) -> None:
+        self._inner_dict['id'] = value
+    
+    
+    @property
+    def values(self) -> List[Union[str, float]]:
+        """Value, reused model from structured properties. Empty if no response was provided."""
+        return self._inner_dict.get('values')  # type: ignore
+    
+    @values.setter
+    def values(self, value: List[Union[str, float]]) -> None:
+        self._inner_dict['values'] = value
+    
+    
+class ActionWorkflowInfoClass(_Aspect):
+    """The ActionWorkflowInfo record captures the metadata and configuration of a workflow.
+    TODO: In the future, we may store the serialized camunda / flowable workflow instance ID inside.
+    We'll likely also need to add the "steps" into here since we'll need that to inform state transitions."""
+
+
+    ASPECT_NAME = 'actionWorkflowInfo'
+    ASPECT_INFO = {}
+    RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.actionworkflow.ActionWorkflowInfo")
+
+    def __init__(self,
+        name: str,
+        category: Union[str, "ActionWorkflowCategoryClass"],
+        trigger: "ActionWorkflowTriggerClass",
+        steps: List["ActionWorkflowStepClass"],
+        created: "AuditStampClass",
+        lastModified: "AuditStampClass",
+        customCategory: Union[None, str]=None,
+        description: Union[None, str]=None,
+    ):
+        super().__init__()
+        
+        self.name = name
+        self.category = category
+        self.customCategory = customCategory
+        self.description = description
+        self.trigger = trigger
+        self.steps = steps
+        self.created = created
+        self.lastModified = lastModified
+    
+    def _restore_defaults(self) -> None:
+        self.name = str()
+        self.category = ActionWorkflowCategoryClass.ACCESS
+        self.customCategory = self.RECORD_SCHEMA.fields_dict["customCategory"].default
+        self.description = self.RECORD_SCHEMA.fields_dict["description"].default
+        self.trigger = ActionWorkflowTriggerClass._construct_with_defaults()
+        self.steps = list()
+        self.created = AuditStampClass._construct_with_defaults()
+        self.lastModified = AuditStampClass._construct_with_defaults()
+    
+    
+    @property
+    def name(self) -> str:
+        """Display name of the workflow"""
+        return self._inner_dict.get('name')  # type: ignore
+    
+    @name.setter
+    def name(self, value: str) -> None:
+        self._inner_dict['name'] = value
+    
+    
+    @property
+    def category(self) -> Union[str, "ActionWorkflowCategoryClass"]:
+        """Top-level category of the workflow, e.g. ACCESS"""
+        return self._inner_dict.get('category')  # type: ignore
+    
+    @category.setter
+    def category(self, value: Union[str, "ActionWorkflowCategoryClass"]) -> None:
+        self._inner_dict['category'] = value
+    
+    
+    @property
+    def customCategory(self) -> Union[None, str]:
+        """Custom category for the workflow, if applicable.
+    
+    This is used to group workflows that are not part of the standard types.
+    Should be provided when the type is CUSTOM."""
+        return self._inner_dict.get('customCategory')  # type: ignore
+    
+    @customCategory.setter
+    def customCategory(self, value: Union[None, str]) -> None:
+        self._inner_dict['customCategory'] = value
+    
+    
+    @property
+    def description(self) -> Union[None, str]:
+        """Description of the workflow. 
+    If this is based on a Form trigger, this will be displayed to users when completing the form. """
+        return self._inner_dict.get('description')  # type: ignore
+    
+    @description.setter
+    def description(self, value: Union[None, str]) -> None:
+        self._inner_dict['description'] = value
+    
+    
+    @property
+    def trigger(self) -> "ActionWorkflowTriggerClass":
+        """The action or event that triggers the workflow. This MUST be stored here, because there is no other
+    place to capture dynamic form state like this. """
+        return self._inner_dict.get('trigger')  # type: ignore
+    
+    @trigger.setter
+    def trigger(self, value: "ActionWorkflowTriggerClass") -> None:
+        self._inner_dict['trigger'] = value
+    
+    
+    @property
+    def steps(self) -> List["ActionWorkflowStepClass"]:
+        """Definition of the steps / tasks / nodes comprising the workflow definition. This is the part we can aim 
+    to be able to convert / transform into serialized XML BPMN Format. For now, we model it strongly here. 
+    If we can successfully use BPMN for step state, we can deprecate this field in place of the XML serialization. 
+    
+    This is the part we'll try to build a transpiler to BPMN for execution for. Ultimately, we do need 
+    a representation we can easily convert into the frontend framework for display. This represents the set of 
+    well known workflow step types - across tasks, conditionals, notifications, etc - that are officially supported today.
+    
+    If necessary, we'll extend this to represent conditional branching nodes as a step / node in the Workflow, e.g. Conditional Step, Notification Step, Review Step"""
+        return self._inner_dict.get('steps')  # type: ignore
+    
+    @steps.setter
+    def steps(self, value: List["ActionWorkflowStepClass"]) -> None:
+        self._inner_dict['steps'] = value
+    
+    
+    @property
+    def created(self) -> "AuditStampClass":
+        """Audit stamp capturing the time and actor who created the workflow."""
+        return self._inner_dict.get('created')  # type: ignore
+    
+    @created.setter
+    def created(self, value: "AuditStampClass") -> None:
+        self._inner_dict['created'] = value
+    
+    
+    @property
+    def lastModified(self) -> "AuditStampClass":
+        """Audit stamp capturing the time and actor who last modified the workflow."""
+        return self._inner_dict.get('lastModified')  # type: ignore
+    
+    @lastModified.setter
+    def lastModified(self, value: "AuditStampClass") -> None:
+        self._inner_dict['lastModified'] = value
+    
+    
+class ActionWorkflowRequestAccessClass(DictWrapper):
+    # No docs available.
+    
+    RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.actionworkflow.ActionWorkflowRequestAccess")
+    def __init__(self,
+        expiresAt: Union[None, int]=None,
+    ):
+        super().__init__()
+        
+        self.expiresAt = expiresAt
+    
+    def _restore_defaults(self) -> None:
+        self.expiresAt = self.RECORD_SCHEMA.fields_dict["expiresAt"].default
+    
+    
+    @property
+    def expiresAt(self) -> Union[None, int]:
+        """Expiration time for the action request (optional, if part of the template)."""
+        return self._inner_dict.get('expiresAt')  # type: ignore
+    
+    @expiresAt.setter
+    def expiresAt(self, value: Union[None, int]) -> None:
+        self._inner_dict['expiresAt'] = value
+    
+    
+class ActionWorkflowRequestStepStateClass(DictWrapper):
+    # No docs available.
+    
+    RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.actionworkflow.ActionWorkflowRequestStepState")
+    def __init__(self,
+        stepId: str,
+    ):
+        super().__init__()
+        
+        self.stepId = stepId
+    
+    def _restore_defaults(self) -> None:
+        self.stepId = str()
+    
+    
+    @property
+    def stepId(self) -> str:
+        """The id of the current step in the workflow, which should be of type ACTION_REQUEST_REVIEW."""
+        return self._inner_dict.get('stepId')  # type: ignore
+    
+    @stepId.setter
+    def stepId(self, value: str) -> None:
+        self._inner_dict['stepId'] = value
+    
+    
+class ActionWorkflowSingleFieldValueConditionClass(DictWrapper):
+    """A specific type of field condition that checks whether a field should be shown based on the value of a previously completed field."""
+    
+    RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.actionworkflow.ActionWorkflowSingleFieldValueCondition")
+    def __init__(self,
+        field: str,
+        values: Optional[List[str]]=None,
+        condition: Optional[Union[str, "ConditionClass"]]=None,
+        negated: Optional[bool]=None,
+    ):
+        super().__init__()
+        
+        self.field = field
+        if values is None:
+            # default: []
+            self.values = list()
+        else:
+            self.values = values
+        if condition is None:
+            # default: 'EQUAL'
+            self.condition = self.RECORD_SCHEMA.fields_dict["condition"].default
+        else:
+            self.condition = condition
+        if negated is None:
+            # default: False
+            self.negated = self.RECORD_SCHEMA.fields_dict["negated"].default
+        else:
+            self.negated = negated
+    
+    def _restore_defaults(self) -> None:
+        self.field = str()
+        self.values = list()
+        self.condition = self.RECORD_SCHEMA.fields_dict["condition"].default
+        self.negated = self.RECORD_SCHEMA.fields_dict["negated"].default
+    
+    
+    @property
+    def field(self) -> str:
+        """The id / name of the field that the criterion refers to"""
+        return self._inner_dict.get('field')  # type: ignore
+    
+    @field.setter
+    def field(self, value: str) -> None:
+        self._inner_dict['field'] = value
+    
+    
+    @property
+    def values(self) -> List[str]:
+        """Values. one of which the intended field should match
+    Note, if values is set, the above "value" field will be ignored"""
+        return self._inner_dict.get('values')  # type: ignore
+    
+    @values.setter
+    def values(self, value: List[str]) -> None:
+        self._inner_dict['values'] = value
+    
+    
+    @property
+    def condition(self) -> Union[str, "ConditionClass"]:
+        """The condition for the criterion, e.g. EQUAL, START_WITH"""
+        return self._inner_dict.get('condition')  # type: ignore
+    
+    @condition.setter
+    def condition(self, value: Union[str, "ConditionClass"]) -> None:
+        self._inner_dict['condition'] = value
+    
+    
+    @property
+    def negated(self) -> bool:
+        """Whether the condition should be negated"""
+        return self._inner_dict.get('negated')  # type: ignore
+    
+    @negated.setter
+    def negated(self, value: bool) -> None:
+        self._inner_dict['negated'] = value
+    
+    
+class ActionWorkflowStepClass(DictWrapper):
+    """Defines a single review step in a workflow.
+    
+    Today, steps are simple. They execute in sequence after the trigger event. 
+    
+    In the future, we may extend steps to include "depends on steps" to form a DAG structure across
+    steps. For now, steps execute in linear sequence after the trigger event -- however the expectation
+    is that they COULD run in parallel after the trigger event without a problem in the future.
+    
+    If necessary, we'll extend this to represent conditional branching nodes as a step / node in the Workflow, e.g. Conditional Step, Notification Step, Review Step
+    
+    Today, step state is reflected via a single entity representing the workflow instance: the ActionRequest entity.
+    In the future we'll explore modeling individual step states separately if required."""
+    
+    RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.actionworkflow.ActionWorkflowStep")
+    def __init__(self,
+        id: str,
+        type: Union[str, "ActionWorkflowStepTypeClass"],
+        description: Union[None, str]=None,
+        actors: Union[None, "ActionWorkflowStepActorsClass"]=None,
+    ):
+        super().__init__()
+        
+        self.id = id
+        self.type = type
+        self.description = description
+        self.actors = actors
+    
+    def _restore_defaults(self) -> None:
+        self.id = str()
+        self.type = ActionWorkflowStepTypeClass.APPROVAL
+        self.description = self.RECORD_SCHEMA.fields_dict["description"].default
+        self.actors = self.RECORD_SCHEMA.fields_dict["actors"].default
+    
+    
+    @property
+    def id(self) -> str:
+        """A unique identifier for this step within the workflow.
+    This ID must be unique within the workflow and is used to match values during workflow execution."""
+        return self._inner_dict.get('id')  # type: ignore
+    
+    @id.setter
+    def id(self, value: str) -> None:
+        self._inner_dict['id'] = value
+    
+    
+    @property
+    def type(self) -> Union[str, "ActionWorkflowStepTypeClass"]:
+        """A type of step / task / node in the Action Workflow. """
+        return self._inner_dict.get('type')  # type: ignore
+    
+    @type.setter
+    def type(self, value: Union[str, "ActionWorkflowStepTypeClass"]) -> None:
+        self._inner_dict['type'] = value
+    
+    
+    @property
+    def description(self) -> Union[None, str]:
+        """Optional description shown alongside the step to explain its purpose."""
+        return self._inner_dict.get('description')  # type: ignore
+    
+    @description.setter
+    def description(self, value: Union[None, str]) -> None:
+        self._inner_dict['description'] = value
+    
+    
+    @property
+    def actors(self) -> Union[None, "ActionWorkflowStepActorsClass"]:
+        """A definition of the actors required to execute the step, if there are any.
+    
+    For steps of type REQUEST_REVIEW, this field MUST be provided! """
+        return self._inner_dict.get('actors')  # type: ignore
+    
+    @actors.setter
+    def actors(self, value: Union[None, "ActionWorkflowStepActorsClass"]) -> None:
+        self._inner_dict['actors'] = value
+    
+    
+class ActionWorkflowStepActorsClass(DictWrapper):
+    """A definition of the actors required to review."""
+    
+    RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.actionworkflow.ActionWorkflowStepActors")
+    def __init__(self,
+        users: List[str],
+        groups: List[str],
+        roles: List[str],
+        dynamicAssignment: Union[None, "ActionWorkflowStepDynamicAssignmentClass"]=None,
+    ):
+        super().__init__()
+        
+        self.users = users
+        self.groups = groups
+        self.roles = roles
+        self.dynamicAssignment = dynamicAssignment
+    
+    def _restore_defaults(self) -> None:
+        self.users = list()
+        self.groups = list()
+        self.roles = list()
+        self.dynamicAssignment = self.RECORD_SCHEMA.fields_dict["dynamicAssignment"].default
+    
+    
+    @property
+    def users(self) -> List[str]:
+        """Users statically assigned to perform the review step."""
+        return self._inner_dict.get('users')  # type: ignore
+    
+    @users.setter
+    def users(self, value: List[str]) -> None:
+        self._inner_dict['users'] = value
+    
+    
+    @property
+    def groups(self) -> List[str]:
+        """Groups statically assigned to perform the review step."""
+        return self._inner_dict.get('groups')  # type: ignore
+    
+    @groups.setter
+    def groups(self, value: List[str]) -> None:
+        self._inner_dict['groups'] = value
+    
+    
+    @property
+    def roles(self) -> List[str]:
+        """Roles statically assigned to perform the review step."""
+        return self._inner_dict.get('roles')  # type: ignore
+    
+    @roles.setter
+    def roles(self, value: List[str]) -> None:
+        self._inner_dict['roles'] = value
+    
+    
+    @property
+    def dynamicAssignment(self) -> Union[None, "ActionWorkflowStepDynamicAssignmentClass"]:
+        """Dynamic assignment type for the review step."""
+        return self._inner_dict.get('dynamicAssignment')  # type: ignore
+    
+    @dynamicAssignment.setter
+    def dynamicAssignment(self, value: Union[None, "ActionWorkflowStepDynamicAssignmentClass"]) -> None:
+        self._inner_dict['dynamicAssignment'] = value
+    
+    
+class ActionWorkflowStepDynamicAssignmentClass(DictWrapper):
+    # No docs available.
+    
+    RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.actionworkflow.ActionWorkflowStepDynamicAssignment")
+    def __init__(self,
+        type: Union[str, "ActionWorkflowStepDynamicAssignmentTypeClass"],
+        ownershipTypeUrns: Union[None, List[str]]=None,
+    ):
+        super().__init__()
+        
+        self.type = type
+        self.ownershipTypeUrns = ownershipTypeUrns
+    
+    def _restore_defaults(self) -> None:
+        self.type = ActionWorkflowStepDynamicAssignmentTypeClass.ENTITY_OWNERS
+        self.ownershipTypeUrns = self.RECORD_SCHEMA.fields_dict["ownershipTypeUrns"].default
+    
+    
+    @property
+    def type(self) -> Union[str, "ActionWorkflowStepDynamicAssignmentTypeClass"]:
+        """A standardized policy for resolving actors dynamically for an access request."""
+        return self._inner_dict.get('type')  # type: ignore
+    
+    @type.setter
+    def type(self, value: Union[str, "ActionWorkflowStepDynamicAssignmentTypeClass"]) -> None:
+        self._inner_dict['type'] = value
+    
+    
+    @property
+    def ownershipTypeUrns(self) -> Union[None, List[str]]:
+        """Optional: A well defined set of ownership type urns to including in routing."""
+        return self._inner_dict.get('ownershipTypeUrns')  # type: ignore
+    
+    @ownershipTypeUrns.setter
+    def ownershipTypeUrns(self, value: Union[None, List[str]]) -> None:
+        self._inner_dict['ownershipTypeUrns'] = value
+    
+    
+class ActionWorkflowStepDynamicAssignmentTypeClass(object):
+    # No docs available.
+    
+    ENTITY_OWNERS = "ENTITY_OWNERS"
+    """Assign the entity owners."""
+    
+    ENTITY_DOMAIN_OWNERS = "ENTITY_DOMAIN_OWNERS"
+    """Assign the entity domain owners."""
+    
+    ENTITY_DATA_PRODUCT_OWNERS = "ENTITY_DATA_PRODUCT_OWNERS"
+    """Assign the entity data product owners."""
+    
+    
+    
+class ActionWorkflowStepTypeClass(object):
+    # No docs available.
+    
+    APPROVAL = "APPROVAL"
+    """The only step type currently supported - a human review step. 
+    This step type requires that an assigned user reviews an action request associated with this workflow. 
+    reviews the request, approving or denying it (currently the actions supported, may extend later). """
+    
+    
+    
+class ActionWorkflowTriggerClass(DictWrapper):
+    """Defines the conditions on which the action workflow is triggered. 
+    
+    Currently we have only one trigger type, but we expect this to extend e.g. in the case that change events, proposals,
+    or other actions can trigger workflows. 
+    
+    Currently, the workflow must have exactly 1 trigger condition. We don't expect this to change. """
+    
+    RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.actionworkflow.ActionWorkflowTrigger")
+    def __init__(self,
+        type: Union[str, "ActionWorkflowTriggerTypeClass"],
+        form: Union[None, "ActionWorkflowFormClass"]=None,
+    ):
+        super().__init__()
+        
+        self.type = type
+        self.form = form
+    
+    def _restore_defaults(self) -> None:
+        self.type = ActionWorkflowTriggerTypeClass.FORM_SUBMITTED
+        self.form = self.RECORD_SCHEMA.fields_dict["form"].default
+    
+    
+    @property
+    def type(self) -> Union[str, "ActionWorkflowTriggerTypeClass"]:
+        """A type of step / task / node in the Action Workflow. """
+        return self._inner_dict.get('type')  # type: ignore
+    
+    @type.setter
+    def type(self, value: Union[str, "ActionWorkflowTriggerTypeClass"]) -> None:
+        self._inner_dict['type'] = value
+    
+    
+    @property
+    def form(self) -> Union[None, "ActionWorkflowFormClass"]:
+        """The form definition that will trigger the action workflow when submitted. """
+        return self._inner_dict.get('form')  # type: ignore
+    
+    @form.setter
+    def form(self, value: Union[None, "ActionWorkflowFormClass"]) -> None:
+        self._inner_dict['form'] = value
+    
+    
+class ActionWorkflowTriggerTypeClass(object):
+    # No docs available.
+    
+    FORM_SUBMITTED = "FORM_SUBMITTED"
+    """The only trigger type currently supported - a workflow request form is submitted successfully. 
+    This enables admins to create forms and display them on various entrypoints. 
+    The form is also captured in the field "form" below. """
+    
+    
+    
 class AiInferenceMetadataClass(_Aspect):
     """AI Inference Metadata of various types."""
 
@@ -17581,6 +18573,12 @@ class NotificationTemplateTypeClass(object):
     
     BROADCAST_COMPLIANCE_FORM_PUBLISH = "BROADCAST_COMPLIANCE_FORM_PUBLISH"
     
+    BROADCAST_NEW_ACTION_WORKFLOW_FORM_REQUEST = "BROADCAST_NEW_ACTION_WORKFLOW_FORM_REQUEST"
+    """Broadcast that a new action workflow form request has been created or needs review."""
+    
+    BROADCAST_ACTION_WORKFLOW_FORM_REQUEST_STATUS_CHANGE = "BROADCAST_ACTION_WORKFLOW_FORM_REQUEST_STATUS_CHANGE"
+    """Broadcast that an action workflow form request has been completed (approved or denied)."""
+    
     INVALID_TEMPLATE = "INVALID_TEMPLATE"
     
     
@@ -22019,6 +23017,35 @@ class ActionRequestKeyClass(_Aspect):
         self._inner_dict['id'] = value
     
     
+class ActionWorkflowKeyClass(_Aspect):
+    """Key for an ActionRequestWorkflow"""
+
+
+    ASPECT_NAME = 'actionWorkflowKey'
+    ASPECT_INFO = {'keyForEntity': 'actionWorkflow', 'entityCategory': 'internal', 'entityAspects': ['actionWorkflowInfo']}
+    RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.metadata.key.ActionWorkflowKey")
+
+    def __init__(self,
+        id: str,
+    ):
+        super().__init__()
+        
+        self.id = id
+    
+    def _restore_defaults(self) -> None:
+        self.id = str()
+    
+    
+    @property
+    def id(self) -> str:
+        """ The unique identifier for the workflow """
+        return self._inner_dict.get('id')  # type: ignore
+    
+    @id.setter
+    def id(self, value: str) -> None:
+        self._inner_dict['id'] = value
+    
+    
 class AnomalyKeyClass(_Aspect):
     """Key for an asset Anomaly"""
 
@@ -38276,6 +39303,26 @@ __SCHEMA_TYPES = {
     'com.linkedin.pegasus2avro.actionrequest.OwnerProposal': OwnerProposalClass,
     'com.linkedin.pegasus2avro.actionrequest.StructuredPropertyProposal': StructuredPropertyProposalClass,
     'com.linkedin.pegasus2avro.actionrequest.TagProposal': TagProposalClass,
+    'com.linkedin.pegasus2avro.actionworkflow.ActionWorkflowCategory': ActionWorkflowCategoryClass,
+    'com.linkedin.pegasus2avro.actionworkflow.ActionWorkflowEntrypoint': ActionWorkflowEntrypointClass,
+    'com.linkedin.pegasus2avro.actionworkflow.ActionWorkflowEntrypointType': ActionWorkflowEntrypointTypeClass,
+    'com.linkedin.pegasus2avro.actionworkflow.ActionWorkflowField': ActionWorkflowFieldClass,
+    'com.linkedin.pegasus2avro.actionworkflow.ActionWorkflowFieldCondition': ActionWorkflowFieldConditionClass,
+    'com.linkedin.pegasus2avro.actionworkflow.ActionWorkflowFieldConditionType': ActionWorkflowFieldConditionTypeClass,
+    'com.linkedin.pegasus2avro.actionworkflow.ActionWorkflowForm': ActionWorkflowFormClass,
+    'com.linkedin.pegasus2avro.actionworkflow.ActionWorkflowFormRequest': ActionWorkflowFormRequestClass,
+    'com.linkedin.pegasus2avro.actionworkflow.ActionWorkflowFormRequestField': ActionWorkflowFormRequestFieldClass,
+    'com.linkedin.pegasus2avro.actionworkflow.ActionWorkflowInfo': ActionWorkflowInfoClass,
+    'com.linkedin.pegasus2avro.actionworkflow.ActionWorkflowRequestAccess': ActionWorkflowRequestAccessClass,
+    'com.linkedin.pegasus2avro.actionworkflow.ActionWorkflowRequestStepState': ActionWorkflowRequestStepStateClass,
+    'com.linkedin.pegasus2avro.actionworkflow.ActionWorkflowSingleFieldValueCondition': ActionWorkflowSingleFieldValueConditionClass,
+    'com.linkedin.pegasus2avro.actionworkflow.ActionWorkflowStep': ActionWorkflowStepClass,
+    'com.linkedin.pegasus2avro.actionworkflow.ActionWorkflowStepActors': ActionWorkflowStepActorsClass,
+    'com.linkedin.pegasus2avro.actionworkflow.ActionWorkflowStepDynamicAssignment': ActionWorkflowStepDynamicAssignmentClass,
+    'com.linkedin.pegasus2avro.actionworkflow.ActionWorkflowStepDynamicAssignmentType': ActionWorkflowStepDynamicAssignmentTypeClass,
+    'com.linkedin.pegasus2avro.actionworkflow.ActionWorkflowStepType': ActionWorkflowStepTypeClass,
+    'com.linkedin.pegasus2avro.actionworkflow.ActionWorkflowTrigger': ActionWorkflowTriggerClass,
+    'com.linkedin.pegasus2avro.actionworkflow.ActionWorkflowTriggerType': ActionWorkflowTriggerTypeClass,
     'com.linkedin.pegasus2avro.ai.AiInferenceMetadata': AiInferenceMetadataClass,
     'com.linkedin.pegasus2avro.ai.EntityInferenceMetadata': EntityInferenceMetadataClass,
     'com.linkedin.pegasus2avro.ai.GlossaryTermsInferenceMetadata': GlossaryTermsInferenceMetadataClass,
@@ -38635,6 +39682,7 @@ __SCHEMA_TYPES = {
     'com.linkedin.pegasus2avro.link.LinkPreviewInfo': LinkPreviewInfoClass,
     'com.linkedin.pegasus2avro.link.LinkPreviewType': LinkPreviewTypeClass,
     'com.linkedin.pegasus2avro.metadata.key.ActionRequestKey': ActionRequestKeyClass,
+    'com.linkedin.pegasus2avro.metadata.key.ActionWorkflowKey': ActionWorkflowKeyClass,
     'com.linkedin.pegasus2avro.metadata.key.AnomalyKey': AnomalyKeyClass,
     'com.linkedin.pegasus2avro.metadata.key.AssertionKey': AssertionKeyClass,
     'com.linkedin.pegasus2avro.metadata.key.ChartKey': ChartKeyClass,
@@ -39011,6 +40059,26 @@ __SCHEMA_TYPES = {
     'OwnerProposal': OwnerProposalClass,
     'StructuredPropertyProposal': StructuredPropertyProposalClass,
     'TagProposal': TagProposalClass,
+    'ActionWorkflowCategory': ActionWorkflowCategoryClass,
+    'ActionWorkflowEntrypoint': ActionWorkflowEntrypointClass,
+    'ActionWorkflowEntrypointType': ActionWorkflowEntrypointTypeClass,
+    'ActionWorkflowField': ActionWorkflowFieldClass,
+    'ActionWorkflowFieldCondition': ActionWorkflowFieldConditionClass,
+    'ActionWorkflowFieldConditionType': ActionWorkflowFieldConditionTypeClass,
+    'ActionWorkflowForm': ActionWorkflowFormClass,
+    'ActionWorkflowFormRequest': ActionWorkflowFormRequestClass,
+    'ActionWorkflowFormRequestField': ActionWorkflowFormRequestFieldClass,
+    'ActionWorkflowInfo': ActionWorkflowInfoClass,
+    'ActionWorkflowRequestAccess': ActionWorkflowRequestAccessClass,
+    'ActionWorkflowRequestStepState': ActionWorkflowRequestStepStateClass,
+    'ActionWorkflowSingleFieldValueCondition': ActionWorkflowSingleFieldValueConditionClass,
+    'ActionWorkflowStep': ActionWorkflowStepClass,
+    'ActionWorkflowStepActors': ActionWorkflowStepActorsClass,
+    'ActionWorkflowStepDynamicAssignment': ActionWorkflowStepDynamicAssignmentClass,
+    'ActionWorkflowStepDynamicAssignmentType': ActionWorkflowStepDynamicAssignmentTypeClass,
+    'ActionWorkflowStepType': ActionWorkflowStepTypeClass,
+    'ActionWorkflowTrigger': ActionWorkflowTriggerClass,
+    'ActionWorkflowTriggerType': ActionWorkflowTriggerTypeClass,
     'AiInferenceMetadata': AiInferenceMetadataClass,
     'EntityInferenceMetadata': EntityInferenceMetadataClass,
     'GlossaryTermsInferenceMetadata': GlossaryTermsInferenceMetadataClass,
@@ -39370,6 +40438,7 @@ __SCHEMA_TYPES = {
     'LinkPreviewInfo': LinkPreviewInfoClass,
     'LinkPreviewType': LinkPreviewTypeClass,
     'ActionRequestKey': ActionRequestKeyClass,
+    'ActionWorkflowKey': ActionWorkflowKeyClass,
     'AnomalyKey': AnomalyKeyClass,
     'AssertionKey': AssertionKeyClass,
     'ChartKey': ChartKeyClass,
@@ -39801,6 +40870,7 @@ ASPECT_CLASSES: List[Type[_Aspect]] = [
     CorpGroupKeyClass,
     VersionSetKeyClass,
     AnomalyKeyClass,
+    ActionWorkflowKeyClass,
     ChartKeyClass,
     DataHubPageTemplateKeyClass,
     OwnershipTypeKeyClass,
@@ -39958,6 +41028,7 @@ ASPECT_CLASSES: List[Type[_Aspect]] = [
     DataContractPropertiesClass,
     DataContractStatusClass,
     MonitorAnomalyEventClass,
+    ActionWorkflowInfoClass,
     DataHubIngestionSourceInfoClass,
     GlossaryTermInfoClass,
     GlossaryNodeInfoClass,
@@ -40092,6 +41163,7 @@ class AspectBag(TypedDict, total=False):
     corpGroupKey: CorpGroupKeyClass
     versionSetKey: VersionSetKeyClass
     anomalyKey: AnomalyKeyClass
+    actionWorkflowKey: ActionWorkflowKeyClass
     chartKey: ChartKeyClass
     dataHubPageTemplateKey: DataHubPageTemplateKeyClass
     ownershipTypeKey: OwnershipTypeKeyClass
@@ -40249,6 +41321,7 @@ class AspectBag(TypedDict, total=False):
     dataContractProperties: DataContractPropertiesClass
     dataContractStatus: DataContractStatusClass
     monitorAnomalyEvent: MonitorAnomalyEventClass
+    actionWorkflowInfo: ActionWorkflowInfoClass
     dataHubIngestionSourceInfo: DataHubIngestionSourceInfoClass
     glossaryTermInfo: GlossaryTermInfoClass
     glossaryNodeInfo: GlossaryNodeInfoClass
@@ -40335,6 +41408,7 @@ KEY_ASPECTS: Dict[str, Type[_Aspect]] = {
     'mlPrimaryKey': MLPrimaryKeyKeyClass,
     'corpGroup': CorpGroupKeyClass,
     'versionSet': VersionSetKeyClass,
+    'actionWorkflow': ActionWorkflowKeyClass,
     'chart': ChartKeyClass,
     'dataHubPageTemplate': DataHubPageTemplateKeyClass,
     'ownershipType': OwnershipTypeKeyClass,
@@ -40412,6 +41486,7 @@ ENTITY_TYPE_NAMES: List[str] = [
     'mlPrimaryKey',
     'corpGroup',
     'versionSet',
+    'actionWorkflow',
     'chart',
     'dataHubPageTemplate',
     'ownershipType',
@@ -40486,6 +41561,7 @@ EntityTypeName = Literal[
     'mlPrimaryKey',
     'corpGroup',
     'versionSet',
+    'actionWorkflow',
     'chart',
     'dataHubPageTemplate',
     'ownershipType',