acryl-datahub-cloud 0.3.13rc3__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."""
 
@@ -2288,7 +3280,6 @@ class AssertionAnalyticsRunEventClass(_Aspect):
         asserteeGlossaryTerms: Union[None, List[str]]=None,
         asserteeOwners: Union[None, List[str]]=None,
         asserteeDataPlatform: Union[None, str]=None,
-        asserteeContainer: Union[None, str]=None,
         asserteeDataPlatformInstance: Union[None, str]=None,
         asserteeSchemaFieldGlossaryTerms: Union[None, List[str]]=None,
         asserteeSchemaFieldTags: Union[None, List[str]]=None,
@@ -2307,7 +3298,6 @@ class AssertionAnalyticsRunEventClass(_Aspect):
         self.asserteeGlossaryTerms = asserteeGlossaryTerms
         self.asserteeOwners = asserteeOwners
         self.asserteeDataPlatform = asserteeDataPlatform
-        self.asserteeContainer = asserteeContainer
         self.asserteeDataPlatformInstance = asserteeDataPlatformInstance
         self.asserteeSchemaFieldGlossaryTerms = asserteeSchemaFieldGlossaryTerms
         self.asserteeSchemaFieldTags = asserteeSchemaFieldTags
@@ -2334,7 +3324,6 @@ class AssertionAnalyticsRunEventClass(_Aspect):
         self.asserteeGlossaryTerms = self.RECORD_SCHEMA.fields_dict["asserteeGlossaryTerms"].default
         self.asserteeOwners = self.RECORD_SCHEMA.fields_dict["asserteeOwners"].default
         self.asserteeDataPlatform = self.RECORD_SCHEMA.fields_dict["asserteeDataPlatform"].default
-        self.asserteeContainer = self.RECORD_SCHEMA.fields_dict["asserteeContainer"].default
         self.asserteeDataPlatformInstance = self.RECORD_SCHEMA.fields_dict["asserteeDataPlatformInstance"].default
         self.asserteeSchemaFieldGlossaryTerms = self.RECORD_SCHEMA.fields_dict["asserteeSchemaFieldGlossaryTerms"].default
         self.asserteeSchemaFieldTags = self.RECORD_SCHEMA.fields_dict["asserteeSchemaFieldTags"].default
@@ -2430,16 +3419,6 @@ class AssertionAnalyticsRunEventClass(_Aspect):
         self._inner_dict['asserteeDataPlatform'] = value
     
     
-    @property
-    def asserteeContainer(self) -> Union[None, str]:
-        """The Container attached to the entity's parent Asset"""
-        return self._inner_dict.get('asserteeContainer')  # type: ignore
-    
-    @asserteeContainer.setter
-    def asserteeContainer(self, value: Union[None, str]) -> None:
-        self._inner_dict['asserteeContainer'] = value
-    
-    
     @property
     def asserteeDataPlatformInstance(self) -> Union[None, str]:
         """Instance of the parent's data platform (e.g. db instance)"""
@@ -2999,7 +3978,6 @@ class AssertionInfoClass(_Aspect):
         source: Union[None, "AssertionSourceClass"]=None,
         lastUpdated: Union[None, "AuditStampClass"]=None,
         description: Union[None, str]=None,
-        note: Union[None, "AssertionNoteClass"]=None,
     ):
         super().__init__()
         
@@ -3020,7 +3998,6 @@ class AssertionInfoClass(_Aspect):
         self.source = source
         self.lastUpdated = lastUpdated
         self.description = description
-        self.note = note
     
     def _restore_defaults(self) -> None:
         self.customProperties = dict()
@@ -3036,7 +4013,6 @@ class AssertionInfoClass(_Aspect):
         self.source = self.RECORD_SCHEMA.fields_dict["source"].default
         self.lastUpdated = self.RECORD_SCHEMA.fields_dict["lastUpdated"].default
         self.description = self.RECORD_SCHEMA.fields_dict["description"].default
-        self.note = self.RECORD_SCHEMA.fields_dict["note"].default
     
     
     @property
@@ -3173,17 +4149,6 @@ class AssertionInfoClass(_Aspect):
         self._inner_dict['description'] = value
     
     
-    @property
-    def note(self) -> Union[None, "AssertionNoteClass"]:
-        """An optional note to give technical owners more context about the assertion, and how to troubleshoot it.
-    The UI will render this in markdown format."""
-        return self._inner_dict.get('note')  # type: ignore
-    
-    @note.setter
-    def note(self, value: Union[None, "AssertionNoteClass"]) -> None:
-        self._inner_dict['note'] = value
-    
-    
 class AssertionMetricClass(DictWrapper):
     # No docs available.
     
@@ -3247,44 +4212,6 @@ class AssertionMonitorSensitivityClass(DictWrapper):
         self._inner_dict['level'] = value
     
     
-class AssertionNoteClass(DictWrapper):
-    # No docs available.
-    
-    RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.assertion.AssertionNote")
-    def __init__(self,
-        content: str,
-        lastModified: "AuditStampClass",
-    ):
-        super().__init__()
-        
-        self.content = content
-        self.lastModified = lastModified
-    
-    def _restore_defaults(self) -> None:
-        self.content = str()
-        self.lastModified = AuditStampClass._construct_with_defaults()
-    
-    
-    @property
-    def content(self) -> str:
-        """The note to give technical owners more context about the assertion, and how to troubleshoot it."""
-        return self._inner_dict.get('content')  # type: ignore
-    
-    @content.setter
-    def content(self, value: str) -> None:
-        self._inner_dict['content'] = value
-    
-    
-    @property
-    def lastModified(self) -> "AuditStampClass":
-        """The time at which the note was last modified."""
-        return self._inner_dict.get('lastModified')  # type: ignore
-    
-    @lastModified.setter
-    def lastModified(self, value: "AuditStampClass") -> None:
-        self._inner_dict['lastModified'] = value
-    
-    
 class AssertionResultClass(DictWrapper):
     """The result of running an assertion"""
     
@@ -17646,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"
     
     
@@ -22055,42 +22988,42 @@ class LinkPreviewTypeClass(object):
     
     
     
-class LogicalParentClass(_Aspect):
-    # No docs available.
+class ActionRequestKeyClass(_Aspect):
+    """Key for an ActionRequest"""
 
 
-    ASPECT_NAME = 'logicalParent'
-    ASPECT_INFO = {}
-    RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.logical.LogicalParent")
+    ASPECT_NAME = 'actionRequestKey'
+    ASPECT_INFO = {'keyForEntity': 'actionRequest', 'entityCategory': 'internal', 'entityAspects': ['actionRequestStatus', 'actionRequestInfo']}
+    RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.metadata.key.ActionRequestKey")
 
     def __init__(self,
-        parent: "EdgeClass",
+        id: str,
     ):
         super().__init__()
         
-        self.parent = parent
+        self.id = id
     
     def _restore_defaults(self) -> None:
-        self.parent = EdgeClass._construct_with_defaults()
+        self.id = str()
     
     
     @property
-    def parent(self) -> "EdgeClass":
+    def id(self) -> str:
         # No docs available.
-        return self._inner_dict.get('parent')  # type: ignore
+        return self._inner_dict.get('id')  # type: ignore
     
-    @parent.setter
-    def parent(self, value: "EdgeClass") -> None:
-        self._inner_dict['parent'] = value
+    @id.setter
+    def id(self, value: str) -> None:
+        self._inner_dict['id'] = value
     
     
-class ActionRequestKeyClass(_Aspect):
-    """Key for an ActionRequest"""
+class ActionWorkflowKeyClass(_Aspect):
+    """Key for an ActionRequestWorkflow"""
 
 
-    ASPECT_NAME = 'actionRequestKey'
-    ASPECT_INFO = {'keyForEntity': 'actionRequest', 'entityCategory': 'internal', 'entityAspects': ['actionRequestStatus', 'actionRequestInfo']}
-    RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.metadata.key.ActionRequestKey")
+    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,
@@ -22105,7 +23038,7 @@ class ActionRequestKeyClass(_Aspect):
     
     @property
     def id(self) -> str:
-        # No docs available.
+        """ The unique identifier for the workflow """
         return self._inner_dict.get('id')  # type: ignore
     
     @id.setter
@@ -23135,7 +24068,7 @@ class DatasetKeyClass(_Aspect):
 
 
     ASPECT_NAME = 'datasetKey'
-    ASPECT_INFO = {'keyForEntity': 'dataset', 'entityCategory': 'core', 'entityAspects': ['viewProperties', 'subTypes', 'datasetProfile', 'datasetUsageStatistics', 'operation', 'domains', 'applications', 'schemaMetadata', 'status', 'container', 'deprecation', 'testResults', 'siblings', 'embed', 'incidentsSummary', 'datasetProperties', 'editableDatasetProperties', 'datasetDeprecation', 'datasetUpstreamLineage', 'upstreamLineage', 'institutionalMemory', 'ownership', 'editableSchemaMetadata', 'globalTags', 'glossaryTerms', 'browsePaths', 'dataPlatformInstance', 'browsePathsV2', 'access', 'structuredProperties', 'forms', 'partitionsSummary', 'versionProperties', 'icebergCatalogInfo', 'logicalParent', 'inferredNeighbors', 'inferredMetadata', 'schemaFieldsInferredMetadata', 'schemaFieldsInferredNeighbors', 'assertionsSummary', 'usageFeatures', 'storageFeatures', 'lineageFeatures', 'proposals', 'schemaProposals', 'anomaliesSummary', 'share', 'origin', 'documentation', 'entityInferenceMetadata'], 'entityDoc': 'Datasets represent logical or physical data assets stored or represented in various data platforms. Tables, Views, Streams are all instances of datasets.'}
+    ASPECT_INFO = {'keyForEntity': 'dataset', 'entityCategory': 'core', 'entityAspects': ['viewProperties', 'subTypes', 'datasetProfile', 'datasetUsageStatistics', 'operation', 'domains', 'applications', 'schemaMetadata', 'status', 'container', 'deprecation', 'testResults', 'siblings', 'embed', 'incidentsSummary', 'datasetProperties', 'editableDatasetProperties', 'datasetDeprecation', 'datasetUpstreamLineage', 'upstreamLineage', 'institutionalMemory', 'ownership', 'editableSchemaMetadata', 'globalTags', 'glossaryTerms', 'browsePaths', 'dataPlatformInstance', 'browsePathsV2', 'access', 'structuredProperties', 'forms', 'partitionsSummary', 'versionProperties', 'icebergCatalogInfo', 'inferredNeighbors', 'inferredMetadata', 'schemaFieldsInferredMetadata', 'schemaFieldsInferredNeighbors', 'assertionsSummary', 'usageFeatures', 'storageFeatures', 'lineageFeatures', 'proposals', 'schemaProposals', 'anomaliesSummary', 'share', 'origin', 'documentation', 'entityInferenceMetadata'], 'entityDoc': 'Datasets represent logical or physical data assets stored or represented in various data platforms. Tables, Views, Streams are all instances of datasets.'}
     RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.metadata.key.DatasetKey")
 
     def __init__(self,
@@ -24163,7 +25096,7 @@ class SchemaFieldKeyClass(_Aspect):
 
 
     ASPECT_NAME = 'schemaFieldKey'
-    ASPECT_INFO = {'keyForEntity': 'schemaField', 'entityCategory': 'core', 'entityAspects': ['schemafieldInfo', 'structuredProperties', 'forms', 'businessAttributes', 'status', 'schemaFieldAliases', 'documentation', 'testResults', 'deprecation', 'subTypes', 'logicalParent', 'schemaFieldProfile', 'lineageFeatures']}
+    ASPECT_INFO = {'keyForEntity': 'schemaField', 'entityCategory': 'core', 'entityAspects': ['schemafieldInfo', 'structuredProperties', 'forms', 'businessAttributes', 'status', 'schemaFieldAliases', 'documentation', 'testResults', 'deprecation', 'subTypes', 'schemaFieldProfile', 'lineageFeatures']}
     RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.metadata.key.SchemaFieldKey")
 
     def __init__(self,
@@ -28412,31 +29345,6 @@ class TrainingDataClass(_Aspect):
         self._inner_dict['trainingData'] = value
     
     
-class AssetCollectionModuleParamsClass(DictWrapper):
-    """The params required if the module is type ASSET_COLLECTION"""
-    
-    RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.module.AssetCollectionModuleParams")
-    def __init__(self,
-        assetUrns: List[str],
-    ):
-        super().__init__()
-        
-        self.assetUrns = assetUrns
-    
-    def _restore_defaults(self) -> None:
-        self.assetUrns = list()
-    
-    
-    @property
-    def assetUrns(self) -> List[str]:
-        # No docs available.
-        return self._inner_dict.get('assetUrns')  # type: ignore
-    
-    @assetUrns.setter
-    def assetUrns(self, value: List[str]) -> None:
-        self._inner_dict['assetUrns'] = value
-    
-    
 class DataHubPageModuleParamsClass(DictWrapper):
     """The specific parameters stored for a module"""
     
@@ -28444,21 +29352,15 @@ class DataHubPageModuleParamsClass(DictWrapper):
     def __init__(self,
         linkParams: Union[None, "LinkModuleParamsClass"]=None,
         richTextParams: Union[None, "RichTextModuleParamsClass"]=None,
-        assetCollectionParams: Union[None, "AssetCollectionModuleParamsClass"]=None,
-        hierarchyViewParams: Union[None, "HierarchyModuleParamsClass"]=None,
     ):
         super().__init__()
         
         self.linkParams = linkParams
         self.richTextParams = richTextParams
-        self.assetCollectionParams = assetCollectionParams
-        self.hierarchyViewParams = hierarchyViewParams
     
     def _restore_defaults(self) -> None:
         self.linkParams = self.RECORD_SCHEMA.fields_dict["linkParams"].default
         self.richTextParams = self.RECORD_SCHEMA.fields_dict["richTextParams"].default
-        self.assetCollectionParams = self.RECORD_SCHEMA.fields_dict["assetCollectionParams"].default
-        self.hierarchyViewParams = self.RECORD_SCHEMA.fields_dict["hierarchyViewParams"].default
     
     
     @property
@@ -28481,26 +29383,6 @@ class DataHubPageModuleParamsClass(DictWrapper):
         self._inner_dict['richTextParams'] = value
     
     
-    @property
-    def assetCollectionParams(self) -> Union[None, "AssetCollectionModuleParamsClass"]:
-        """The params required if the module is type ASSET_COLLECTION"""
-        return self._inner_dict.get('assetCollectionParams')  # type: ignore
-    
-    @assetCollectionParams.setter
-    def assetCollectionParams(self, value: Union[None, "AssetCollectionModuleParamsClass"]) -> None:
-        self._inner_dict['assetCollectionParams'] = value
-    
-    
-    @property
-    def hierarchyViewParams(self) -> Union[None, "HierarchyModuleParamsClass"]:
-        """The params required if the module is type HIERARCHY_VIEW"""
-        return self._inner_dict.get('hierarchyViewParams')  # type: ignore
-    
-    @hierarchyViewParams.setter
-    def hierarchyViewParams(self, value: Union[None, "HierarchyModuleParamsClass"]) -> None:
-        self._inner_dict['hierarchyViewParams'] = value
-    
-    
 class DataHubPageModulePropertiesClass(_Aspect):
     """The main properties of a DataHub page module"""
 
@@ -28616,9 +29498,6 @@ class DataHubPageModuleTypeClass(object):
     DOMAINS = "DOMAINS"
     """Module displaying the top domains"""
     
-    SUBSCRIBED_ASSETS = "SUBSCRIBED_ASSETS"
-    """Module displaying assets subscribed to by a given user"""
-    
     
     
 class DataHubPageModuleVisibilityClass(DictWrapper):
@@ -28646,110 +29525,29 @@ class DataHubPageModuleVisibilityClass(DictWrapper):
         self._inner_dict['scope'] = value
     
     
-class HierarchyModuleParamsClass(DictWrapper):
-    """The params required if the module is type HIERARCHY_VIEW"""
-    
-    RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.module.HierarchyModuleParams")
-    def __init__(self,
-        showRelatedEntities: bool,
-        assetUrns: Union[None, List[str]]=None,
-        relatedEntitiesFilterJson: Union[None, str]=None,
-    ):
-        super().__init__()
-        
-        self.assetUrns = assetUrns
-        self.showRelatedEntities = showRelatedEntities
-        self.relatedEntitiesFilterJson = relatedEntitiesFilterJson
-    
-    def _restore_defaults(self) -> None:
-        self.assetUrns = self.RECORD_SCHEMA.fields_dict["assetUrns"].default
-        self.showRelatedEntities = bool()
-        self.relatedEntitiesFilterJson = self.RECORD_SCHEMA.fields_dict["relatedEntitiesFilterJson"].default
-    
-    
-    @property
-    def assetUrns(self) -> Union[None, List[str]]:
-        # No docs available.
-        return self._inner_dict.get('assetUrns')  # type: ignore
-    
-    @assetUrns.setter
-    def assetUrns(self, value: Union[None, List[str]]) -> None:
-        self._inner_dict['assetUrns'] = value
-    
-    
-    @property
-    def showRelatedEntities(self) -> bool:
-        # No docs available.
-        return self._inner_dict.get('showRelatedEntities')  # type: ignore
-    
-    @showRelatedEntities.setter
-    def showRelatedEntities(self, value: bool) -> None:
-        self._inner_dict['showRelatedEntities'] = value
-    
-    
-    @property
-    def relatedEntitiesFilterJson(self) -> Union[None, str]:
-        """Optional filters to filter relatedEntities (assetUrns) out
-    
-    The stringified json representing the logical predicate built in the UI to select assets.
-    This predicate is turned into orFilters to send through graphql since graphql doesn't support
-    arbitrary nesting. This string is used to restore the UI for this logical predicate."""
-        return self._inner_dict.get('relatedEntitiesFilterJson')  # type: ignore
-    
-    @relatedEntitiesFilterJson.setter
-    def relatedEntitiesFilterJson(self, value: Union[None, str]) -> None:
-        self._inner_dict['relatedEntitiesFilterJson'] = value
-    
-    
 class LinkModuleParamsClass(DictWrapper):
     # No docs available.
     
     RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.module.LinkModuleParams")
     def __init__(self,
-        linkUrl: str,
-        imageUrl: Union[None, str]=None,
-        description: Union[None, str]=None,
+        linkUrn: str,
     ):
         super().__init__()
         
-        self.linkUrl = linkUrl
-        self.imageUrl = imageUrl
-        self.description = description
+        self.linkUrn = linkUrn
     
     def _restore_defaults(self) -> None:
-        self.linkUrl = str()
-        self.imageUrl = self.RECORD_SCHEMA.fields_dict["imageUrl"].default
-        self.description = self.RECORD_SCHEMA.fields_dict["description"].default
-    
-    
-    @property
-    def linkUrl(self) -> str:
-        # No docs available.
-        return self._inner_dict.get('linkUrl')  # type: ignore
-    
-    @linkUrl.setter
-    def linkUrl(self, value: str) -> None:
-        self._inner_dict['linkUrl'] = value
+        self.linkUrn = str()
     
     
     @property
-    def imageUrl(self) -> Union[None, str]:
+    def linkUrn(self) -> str:
         # No docs available.
-        return self._inner_dict.get('imageUrl')  # type: ignore
-    
-    @imageUrl.setter
-    def imageUrl(self, value: Union[None, str]) -> None:
-        self._inner_dict['imageUrl'] = value
+        return self._inner_dict.get('linkUrn')  # type: ignore
     
-    
-    @property
-    def description(self) -> Union[None, str]:
-        # No docs available.
-        return self._inner_dict.get('description')  # type: ignore
-    
-    @description.setter
-    def description(self, value: Union[None, str]) -> None:
-        self._inner_dict['description'] = value
+    @linkUrn.setter
+    def linkUrn(self, value: str) -> None:
+        self._inner_dict['linkUrn'] = value
     
     
 class PageModuleScopeClass(object):
@@ -30686,8 +31484,6 @@ class SystemMetadataClass(_Aspect):
         registryVersion: Union[None, str]=None,
         properties: Union[None, Dict[str, str]]=None,
         version: Union[None, str]=None,
-        aspectCreated: Union[None, "AuditStampClass"]=None,
-        aspectModified: Union[None, "AuditStampClass"]=None,
     ):
         super().__init__()
         
@@ -30711,8 +31507,6 @@ class SystemMetadataClass(_Aspect):
         self.registryVersion = registryVersion
         self.properties = properties
         self.version = version
-        self.aspectCreated = aspectCreated
-        self.aspectModified = aspectModified
     
     def _restore_defaults(self) -> None:
         self.lastObserved = self.RECORD_SCHEMA.fields_dict["lastObserved"].default
@@ -30723,8 +31517,6 @@ class SystemMetadataClass(_Aspect):
         self.registryVersion = self.RECORD_SCHEMA.fields_dict["registryVersion"].default
         self.properties = self.RECORD_SCHEMA.fields_dict["properties"].default
         self.version = self.RECORD_SCHEMA.fields_dict["version"].default
-        self.aspectCreated = self.RECORD_SCHEMA.fields_dict["aspectCreated"].default
-        self.aspectModified = self.RECORD_SCHEMA.fields_dict["aspectModified"].default
     
     
     @property
@@ -30809,26 +31601,6 @@ class SystemMetadataClass(_Aspect):
         self._inner_dict['version'] = value
     
     
-    @property
-    def aspectCreated(self) -> Union[None, "AuditStampClass"]:
-        """When the aspect was initially created and who created it, detected by version 0 -> 1 change"""
-        return self._inner_dict.get('aspectCreated')  # type: ignore
-    
-    @aspectCreated.setter
-    def aspectCreated(self, value: Union[None, "AuditStampClass"]) -> None:
-        self._inner_dict['aspectCreated'] = value
-    
-    
-    @property
-    def aspectModified(self) -> Union[None, "AuditStampClass"]:
-        """When the aspect was last modified and the actor that performed the modification"""
-        return self._inner_dict.get('aspectModified')  # type: ignore
-    
-    @aspectModified.setter
-    def aspectModified(self, value: Union[None, "AuditStampClass"]) -> None:
-        self._inner_dict['aspectModified'] = value
-    
-    
 class ChartCellClass(DictWrapper):
     """Chart cell in a notebook, which will present content in chart format"""
     
@@ -35641,7 +36413,6 @@ class SlackIntegrationSettingsClass(DictWrapper):
         enabled: Optional[bool]=None,
         encryptedBotToken: Union[None, str]=None,
         defaultChannelName: Union[None, str]=None,
-        datahubAtMentionEnabled: Union[None, bool]=None,
     ):
         super().__init__()
         
@@ -35652,13 +36423,11 @@ class SlackIntegrationSettingsClass(DictWrapper):
             self.enabled = enabled
         self.encryptedBotToken = encryptedBotToken
         self.defaultChannelName = defaultChannelName
-        self.datahubAtMentionEnabled = datahubAtMentionEnabled
     
     def _restore_defaults(self) -> None:
         self.enabled = self.RECORD_SCHEMA.fields_dict["enabled"].default
         self.encryptedBotToken = self.RECORD_SCHEMA.fields_dict["encryptedBotToken"].default
         self.defaultChannelName = self.RECORD_SCHEMA.fields_dict["defaultChannelName"].default
-        self.datahubAtMentionEnabled = self.RECORD_SCHEMA.fields_dict["datahubAtMentionEnabled"].default
     
     
     @property
@@ -35694,17 +36463,6 @@ class SlackIntegrationSettingsClass(DictWrapper):
         self._inner_dict['defaultChannelName'] = value
     
     
-    @property
-    def datahubAtMentionEnabled(self) -> Union[None, bool]:
-        """Whether the Slack @DataHub bot mention functionality is enabled.
-    If null, use the default value from feature flags."""
-        return self._inner_dict.get('datahubAtMentionEnabled')  # type: ignore
-    
-    @datahubAtMentionEnabled.setter
-    def datahubAtMentionEnabled(self, value: Union[None, bool]) -> None:
-        self._inner_dict['datahubAtMentionEnabled'] = value
-    
-    
 class SsoSettingsClass(DictWrapper):
     """SSO Integrations, supported on the UI."""
     
@@ -38545,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,
@@ -38572,7 +39350,6 @@ __SCHEMA_TYPES = {
     'com.linkedin.pegasus2avro.assertion.AssertionInfo': AssertionInfoClass,
     'com.linkedin.pegasus2avro.assertion.AssertionMetric': AssertionMetricClass,
     'com.linkedin.pegasus2avro.assertion.AssertionMonitorSensitivity': AssertionMonitorSensitivityClass,
-    'com.linkedin.pegasus2avro.assertion.AssertionNote': AssertionNoteClass,
     'com.linkedin.pegasus2avro.assertion.AssertionResult': AssertionResultClass,
     'com.linkedin.pegasus2avro.assertion.AssertionResultError': AssertionResultErrorClass,
     'com.linkedin.pegasus2avro.assertion.AssertionResultErrorType': AssertionResultErrorTypeClass,
@@ -38904,8 +39681,8 @@ __SCHEMA_TYPES = {
     'com.linkedin.pegasus2avro.ingestion.DataHubIngestionSourceSourceType': DataHubIngestionSourceSourceTypeClass,
     'com.linkedin.pegasus2avro.link.LinkPreviewInfo': LinkPreviewInfoClass,
     'com.linkedin.pegasus2avro.link.LinkPreviewType': LinkPreviewTypeClass,
-    'com.linkedin.pegasus2avro.logical.LogicalParent': LogicalParentClass,
     '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,
@@ -39048,12 +39825,10 @@ __SCHEMA_TYPES = {
     'com.linkedin.pegasus2avro.ml.metadata.SourceCodeUrl': SourceCodeUrlClass,
     'com.linkedin.pegasus2avro.ml.metadata.SourceCodeUrlType': SourceCodeUrlTypeClass,
     'com.linkedin.pegasus2avro.ml.metadata.TrainingData': TrainingDataClass,
-    'com.linkedin.pegasus2avro.module.AssetCollectionModuleParams': AssetCollectionModuleParamsClass,
     'com.linkedin.pegasus2avro.module.DataHubPageModuleParams': DataHubPageModuleParamsClass,
     'com.linkedin.pegasus2avro.module.DataHubPageModuleProperties': DataHubPageModulePropertiesClass,
     'com.linkedin.pegasus2avro.module.DataHubPageModuleType': DataHubPageModuleTypeClass,
     'com.linkedin.pegasus2avro.module.DataHubPageModuleVisibility': DataHubPageModuleVisibilityClass,
-    'com.linkedin.pegasus2avro.module.HierarchyModuleParams': HierarchyModuleParamsClass,
     'com.linkedin.pegasus2avro.module.LinkModuleParams': LinkModuleParamsClass,
     'com.linkedin.pegasus2avro.module.PageModuleScope': PageModuleScopeClass,
     'com.linkedin.pegasus2avro.module.RichTextModuleParams': RichTextModuleParamsClass,
@@ -39284,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,
@@ -39311,7 +40106,6 @@ __SCHEMA_TYPES = {
     'AssertionInfo': AssertionInfoClass,
     'AssertionMetric': AssertionMetricClass,
     'AssertionMonitorSensitivity': AssertionMonitorSensitivityClass,
-    'AssertionNote': AssertionNoteClass,
     'AssertionResult': AssertionResultClass,
     'AssertionResultError': AssertionResultErrorClass,
     'AssertionResultErrorType': AssertionResultErrorTypeClass,
@@ -39643,8 +40437,8 @@ __SCHEMA_TYPES = {
     'DataHubIngestionSourceSourceType': DataHubIngestionSourceSourceTypeClass,
     'LinkPreviewInfo': LinkPreviewInfoClass,
     'LinkPreviewType': LinkPreviewTypeClass,
-    'LogicalParent': LogicalParentClass,
     'ActionRequestKey': ActionRequestKeyClass,
+    'ActionWorkflowKey': ActionWorkflowKeyClass,
     'AnomalyKey': AnomalyKeyClass,
     'AssertionKey': AssertionKeyClass,
     'ChartKey': ChartKeyClass,
@@ -39787,12 +40581,10 @@ __SCHEMA_TYPES = {
     'SourceCodeUrl': SourceCodeUrlClass,
     'SourceCodeUrlType': SourceCodeUrlTypeClass,
     'TrainingData': TrainingDataClass,
-    'AssetCollectionModuleParams': AssetCollectionModuleParamsClass,
     'DataHubPageModuleParams': DataHubPageModuleParamsClass,
     'DataHubPageModuleProperties': DataHubPageModulePropertiesClass,
     'DataHubPageModuleType': DataHubPageModuleTypeClass,
     'DataHubPageModuleVisibility': DataHubPageModuleVisibilityClass,
-    'HierarchyModuleParams': HierarchyModuleParamsClass,
     'LinkModuleParams': LinkModuleParamsClass,
     'PageModuleScope': PageModuleScopeClass,
     'RichTextModuleParams': RichTextModuleParamsClass,
@@ -40078,6 +40870,7 @@ ASPECT_CLASSES: List[Type[_Aspect]] = [
     CorpGroupKeyClass,
     VersionSetKeyClass,
     AnomalyKeyClass,
+    ActionWorkflowKeyClass,
     ChartKeyClass,
     DataHubPageTemplateKeyClass,
     OwnershipTypeKeyClass,
@@ -40168,7 +40961,6 @@ ASPECT_CLASSES: List[Type[_Aspect]] = [
     BusinessAttributeInfoClass,
     BusinessAttributeKeyClass,
     BusinessAttributesClass,
-    LogicalParentClass,
     LinkPreviewInfoClass,
     GlobalSettingsInfoClass,
     TelemetryClientIdClass,
@@ -40236,6 +41028,7 @@ ASPECT_CLASSES: List[Type[_Aspect]] = [
     DataContractPropertiesClass,
     DataContractStatusClass,
     MonitorAnomalyEventClass,
+    ActionWorkflowInfoClass,
     DataHubIngestionSourceInfoClass,
     GlossaryTermInfoClass,
     GlossaryNodeInfoClass,
@@ -40370,6 +41163,7 @@ class AspectBag(TypedDict, total=False):
     corpGroupKey: CorpGroupKeyClass
     versionSetKey: VersionSetKeyClass
     anomalyKey: AnomalyKeyClass
+    actionWorkflowKey: ActionWorkflowKeyClass
     chartKey: ChartKeyClass
     dataHubPageTemplateKey: DataHubPageTemplateKeyClass
     ownershipTypeKey: OwnershipTypeKeyClass
@@ -40460,7 +41254,6 @@ class AspectBag(TypedDict, total=False):
     businessAttributeInfo: BusinessAttributeInfoClass
     businessAttributeKey: BusinessAttributeKeyClass
     businessAttributes: BusinessAttributesClass
-    logicalParent: LogicalParentClass
     linkPreviewInfo: LinkPreviewInfoClass
     globalSettingsInfo: GlobalSettingsInfoClass
     telemetryClientId: TelemetryClientIdClass
@@ -40528,6 +41321,7 @@ class AspectBag(TypedDict, total=False):
     dataContractProperties: DataContractPropertiesClass
     dataContractStatus: DataContractStatusClass
     monitorAnomalyEvent: MonitorAnomalyEventClass
+    actionWorkflowInfo: ActionWorkflowInfoClass
     dataHubIngestionSourceInfo: DataHubIngestionSourceInfoClass
     glossaryTermInfo: GlossaryTermInfoClass
     glossaryNodeInfo: GlossaryNodeInfoClass
@@ -40614,6 +41408,7 @@ KEY_ASPECTS: Dict[str, Type[_Aspect]] = {
     'mlPrimaryKey': MLPrimaryKeyKeyClass,
     'corpGroup': CorpGroupKeyClass,
     'versionSet': VersionSetKeyClass,
+    'actionWorkflow': ActionWorkflowKeyClass,
     'chart': ChartKeyClass,
     'dataHubPageTemplate': DataHubPageTemplateKeyClass,
     'ownershipType': OwnershipTypeKeyClass,
@@ -40691,6 +41486,7 @@ ENTITY_TYPE_NAMES: List[str] = [
     'mlPrimaryKey',
     'corpGroup',
     'versionSet',
+    'actionWorkflow',
     'chart',
     'dataHubPageTemplate',
     'ownershipType',
@@ -40765,6 +41561,7 @@ EntityTypeName = Literal[
     'mlPrimaryKey',
     'corpGroup',
     'versionSet',
+    'actionWorkflow',
     'chart',
     'dataHubPageTemplate',
     'ownershipType',