acryl-datahub-cloud 0.3.12.4rc2__py3-none-any.whl → 0.3.13__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,6 +3280,7 @@ 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,
@@ -2306,6 +3299,7 @@ class AssertionAnalyticsRunEventClass(_Aspect):
         self.asserteeGlossaryTerms = asserteeGlossaryTerms
         self.asserteeOwners = asserteeOwners
         self.asserteeDataPlatform = asserteeDataPlatform
+        self.asserteeContainer = asserteeContainer
         self.asserteeDataPlatformInstance = asserteeDataPlatformInstance
         self.asserteeSchemaFieldGlossaryTerms = asserteeSchemaFieldGlossaryTerms
         self.asserteeSchemaFieldTags = asserteeSchemaFieldTags
@@ -2332,6 +3326,7 @@ 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
@@ -2427,6 +3422,16 @@ 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)"""
@@ -2986,6 +3991,7 @@ 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__()
         
@@ -3006,6 +4012,7 @@ class AssertionInfoClass(_Aspect):
         self.source = source
         self.lastUpdated = lastUpdated
         self.description = description
+        self.note = note
     
     def _restore_defaults(self) -> None:
         self.customProperties = dict()
@@ -3021,6 +4028,7 @@ 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
@@ -3157,6 +4165,17 @@ 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.
     
@@ -3220,6 +4239,44 @@ 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"""
     
@@ -17581,6 +18638,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"
     
     
@@ -19945,6 +21008,44 @@ class CorpUserEditableInfoClass(_Aspect):
         self._inner_dict['informationSources'] = value
     
     
+class CorpUserHomePageSettingsClass(DictWrapper):
+    """Settings related to the home page for a user"""
+    
+    RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.identity.CorpUserHomePageSettings")
+    def __init__(self,
+        pageTemplate: Union[None, str]=None,
+        dismissedAnnouncements: Union[None, List[str]]=None,
+    ):
+        super().__init__()
+        
+        self.pageTemplate = pageTemplate
+        self.dismissedAnnouncements = dismissedAnnouncements
+    
+    def _restore_defaults(self) -> None:
+        self.pageTemplate = self.RECORD_SCHEMA.fields_dict["pageTemplate"].default
+        self.dismissedAnnouncements = self.RECORD_SCHEMA.fields_dict["dismissedAnnouncements"].default
+    
+    
+    @property
+    def pageTemplate(self) -> Union[None, str]:
+        """The page template that will be rendered in the UI by default for this user"""
+        return self._inner_dict.get('pageTemplate')  # type: ignore
+    
+    @pageTemplate.setter
+    def pageTemplate(self, value: Union[None, str]) -> None:
+        self._inner_dict['pageTemplate'] = value
+    
+    
+    @property
+    def dismissedAnnouncements(self) -> Union[None, List[str]]:
+        """The list of announcement urns that have been dismissed by the user"""
+        return self._inner_dict.get('dismissedAnnouncements')  # type: ignore
+    
+    @dismissedAnnouncements.setter
+    def dismissedAnnouncements(self, value: Union[None, List[str]]) -> None:
+        self._inner_dict['dismissedAnnouncements'] = value
+    
+    
 class CorpUserInfoClass(_Aspect):
     """Linkedin corp user information"""
 
@@ -20150,17 +21251,20 @@ class CorpUserSettingsClass(_Aspect):
         appearance: "CorpUserAppearanceSettingsClass",
         views: Union[None, "CorpUserViewsSettingsClass"]=None,
         notificationSettings: Union[None, "NotificationSettingsClass"]=None,
+        homePage: Union[None, "CorpUserHomePageSettingsClass"]=None,
     ):
         super().__init__()
         
         self.appearance = appearance
         self.views = views
         self.notificationSettings = notificationSettings
+        self.homePage = homePage
     
     def _restore_defaults(self) -> None:
         self.appearance = CorpUserAppearanceSettingsClass._construct_with_defaults()
         self.views = self.RECORD_SCHEMA.fields_dict["views"].default
         self.notificationSettings = self.RECORD_SCHEMA.fields_dict["notificationSettings"].default
+        self.homePage = self.RECORD_SCHEMA.fields_dict["homePage"].default
     
     
     @property
@@ -20193,6 +21297,16 @@ class CorpUserSettingsClass(_Aspect):
         self._inner_dict['notificationSettings'] = value
     
     
+    @property
+    def homePage(self) -> Union[None, "CorpUserHomePageSettingsClass"]:
+        """Settings related to the home page for a user"""
+        return self._inner_dict.get('homePage')  # type: ignore
+    
+    @homePage.setter
+    def homePage(self, value: Union[None, "CorpUserHomePageSettingsClass"]) -> None:
+        self._inner_dict['homePage'] = value
+    
+    
 class CorpUserStatusClass(_Aspect):
     """The status of the user, e.g. provisioned, active, suspended, etc."""
 
@@ -21939,6 +23053,35 @@ class LinkPreviewTypeClass(object):
     
     
     
+class LogicalParentClass(_Aspect):
+    # No docs available.
+
+
+    ASPECT_NAME = 'logicalParent'
+    ASPECT_INFO = {}
+    RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.logical.LogicalParent")
+
+    def __init__(self,
+        parent: "EdgeClass",
+    ):
+        super().__init__()
+        
+        self.parent = parent
+    
+    def _restore_defaults(self) -> None:
+        self.parent = EdgeClass._construct_with_defaults()
+    
+    
+    @property
+    def parent(self) -> "EdgeClass":
+        # No docs available.
+        return self._inner_dict.get('parent')  # type: ignore
+    
+    @parent.setter
+    def parent(self, value: "EdgeClass") -> None:
+        self._inner_dict['parent'] = value
+    
+    
 class ActionRequestKeyClass(_Aspect):
     """Key for an ActionRequest"""
 
@@ -21968,6 +23111,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"""
 
@@ -22484,6 +23656,64 @@ class DataHubOpenAPISchemaKeyClass(_Aspect):
         self._inner_dict['id'] = value
     
     
+class DataHubPageModuleKeyClass(_Aspect):
+    """Key for a DataHubPageModule"""
+
+
+    ASPECT_NAME = 'dataHubPageModuleKey'
+    ASPECT_INFO = {'keyForEntity': 'dataHubPageModule', 'entityCategory': 'core', 'entityAspects': ['dataHubPageModuleProperties']}
+    RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.metadata.key.DataHubPageModuleKey")
+
+    def __init__(self,
+        id: str,
+    ):
+        super().__init__()
+        
+        self.id = id
+    
+    def _restore_defaults(self) -> None:
+        self.id = str()
+    
+    
+    @property
+    def id(self) -> str:
+        """Unique id for the module."""
+        return self._inner_dict.get('id')  # type: ignore
+    
+    @id.setter
+    def id(self, value: str) -> None:
+        self._inner_dict['id'] = value
+    
+    
+class DataHubPageTemplateKeyClass(_Aspect):
+    """Key for a DataHubPageTemplate"""
+
+
+    ASPECT_NAME = 'dataHubPageTemplateKey'
+    ASPECT_INFO = {'keyForEntity': 'dataHubPageTemplate', 'entityCategory': 'core', 'entityAspects': ['dataHubPageTemplateProperties']}
+    RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.metadata.key.DataHubPageTemplateKey")
+
+    def __init__(self,
+        id: str,
+    ):
+        super().__init__()
+        
+        self.id = id
+    
+    def _restore_defaults(self) -> None:
+        self.id = str()
+    
+    
+    @property
+    def id(self) -> str:
+        """Unique id for the template."""
+        return self._inner_dict.get('id')  # type: ignore
+    
+    @id.setter
+    def id(self, value: str) -> None:
+        self._inner_dict['id'] = value
+    
+    
 class DataHubPersonaKeyClass(_Aspect):
     """Key for a persona type"""
 
@@ -22932,7 +24162,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', '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', '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.'}
     RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.metadata.key.DatasetKey")
 
     def __init__(self,
@@ -23960,7 +25190,7 @@ class SchemaFieldKeyClass(_Aspect):
 
 
     ASPECT_NAME = 'schemaFieldKey'
-    ASPECT_INFO = {'keyForEntity': 'schemaField', 'entityCategory': 'core', 'entityAspects': ['schemafieldInfo', 'structuredProperties', 'forms', 'businessAttributes', 'status', 'schemaFieldAliases', 'documentation', 'testResults', 'deprecation', 'subTypes', 'schemaFieldProfile', 'lineageFeatures']}
+    ASPECT_INFO = {'keyForEntity': 'schemaField', 'entityCategory': 'core', 'entityAspects': ['schemafieldInfo', 'structuredProperties', 'forms', 'businessAttributes', 'status', 'schemaFieldAliases', 'documentation', 'testResults', 'deprecation', 'subTypes', 'logicalParent', 'schemaFieldProfile', 'lineageFeatures']}
     RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.metadata.key.SchemaFieldKey")
 
     def __init__(self,
@@ -28209,6 +29439,382 @@ 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"""
+    
+    RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.module.DataHubPageModuleParams")
+    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
+    def linkParams(self) -> Union[None, "LinkModuleParamsClass"]:
+        """The params required if the module is type LINK"""
+        return self._inner_dict.get('linkParams')  # type: ignore
+    
+    @linkParams.setter
+    def linkParams(self, value: Union[None, "LinkModuleParamsClass"]) -> None:
+        self._inner_dict['linkParams'] = value
+    
+    
+    @property
+    def richTextParams(self) -> Union[None, "RichTextModuleParamsClass"]:
+        """The params required if the module is type RICH_TEXT"""
+        return self._inner_dict.get('richTextParams')  # type: ignore
+    
+    @richTextParams.setter
+    def richTextParams(self, value: Union[None, "RichTextModuleParamsClass"]) -> None:
+        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"""
+
+
+    ASPECT_NAME = 'dataHubPageModuleProperties'
+    ASPECT_INFO = {}
+    RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.module.DataHubPageModuleProperties")
+
+    def __init__(self,
+        name: str,
+        type: Union[str, "DataHubPageModuleTypeClass"],
+        visibility: "DataHubPageModuleVisibilityClass",
+        params: "DataHubPageModuleParamsClass",
+        created: "AuditStampClass",
+        lastModified: "AuditStampClass",
+    ):
+        super().__init__()
+        
+        self.name = name
+        self.type = type
+        self.visibility = visibility
+        self.params = params
+        self.created = created
+        self.lastModified = lastModified
+    
+    def _restore_defaults(self) -> None:
+        self.name = str()
+        self.type = DataHubPageModuleTypeClass.LINK
+        self.visibility = DataHubPageModuleVisibilityClass._construct_with_defaults()
+        self.params = DataHubPageModuleParamsClass._construct_with_defaults()
+        self.created = AuditStampClass._construct_with_defaults()
+        self.lastModified = AuditStampClass._construct_with_defaults()
+    
+    
+    @property
+    def name(self) -> str:
+        """The display name of this module"""
+        return self._inner_dict.get('name')  # type: ignore
+    
+    @name.setter
+    def name(self, value: str) -> None:
+        self._inner_dict['name'] = value
+    
+    
+    @property
+    def type(self) -> Union[str, "DataHubPageModuleTypeClass"]:
+        """The type of this module - the purpose it serves"""
+        return self._inner_dict.get('type')  # type: ignore
+    
+    @type.setter
+    def type(self, value: Union[str, "DataHubPageModuleTypeClass"]) -> None:
+        self._inner_dict['type'] = value
+    
+    
+    @property
+    def visibility(self) -> "DataHubPageModuleVisibilityClass":
+        """Info about the visibility of this module"""
+        return self._inner_dict.get('visibility')  # type: ignore
+    
+    @visibility.setter
+    def visibility(self, value: "DataHubPageModuleVisibilityClass") -> None:
+        self._inner_dict['visibility'] = value
+    
+    
+    @property
+    def params(self) -> "DataHubPageModuleParamsClass":
+        """The specific parameters stored for this module"""
+        return self._inner_dict.get('params')  # type: ignore
+    
+    @params.setter
+    def params(self, value: "DataHubPageModuleParamsClass") -> None:
+        self._inner_dict['params'] = value
+    
+    
+    @property
+    def created(self) -> "AuditStampClass":
+        """Audit stamp for when and by whom this template was created"""
+        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 for when and by whom this template was last updated"""
+        return self._inner_dict.get('lastModified')  # type: ignore
+    
+    @lastModified.setter
+    def lastModified(self, value: "AuditStampClass") -> None:
+        self._inner_dict['lastModified'] = value
+    
+    
+class DataHubPageModuleTypeClass(object):
+    """Enum containing the types of page modules that there are"""
+    
+    LINK = "LINK"
+    """Link type module"""
+    
+    RICH_TEXT = "RICH_TEXT"
+    """Module containing rich text to be rendered"""
+    
+    ASSET_COLLECTION = "ASSET_COLLECTION"
+    """A module with a collection of assets"""
+    
+    HIERARCHY = "HIERARCHY"
+    """A module displaying a hierarchy to navigate"""
+    
+    OWNED_ASSETS = "OWNED_ASSETS"
+    """Module displaying assets owned by a user"""
+    
+    DOMAINS = "DOMAINS"
+    """Module displaying the top domains"""
+    
+    SUBSCRIBED_ASSETS = "SUBSCRIBED_ASSETS"
+    """Module displaying assets subscribed to by a given user"""
+    
+    
+    
+class DataHubPageModuleVisibilityClass(DictWrapper):
+    """Info about the visibility of this module"""
+    
+    RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.module.DataHubPageModuleVisibility")
+    def __init__(self,
+        scope: Union[str, "PageModuleScopeClass"],
+    ):
+        super().__init__()
+        
+        self.scope = scope
+    
+    def _restore_defaults(self) -> None:
+        self.scope = PageModuleScopeClass.PERSONAL
+    
+    
+    @property
+    def scope(self) -> Union[str, "PageModuleScopeClass"]:
+        """Audit stamp for when and by whom this module was created"""
+        return self._inner_dict.get('scope')  # type: ignore
+    
+    @scope.setter
+    def scope(self, value: Union[str, "PageModuleScopeClass"]) -> None:
+        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,
+    ):
+        super().__init__()
+        
+        self.linkUrl = linkUrl
+        self.imageUrl = imageUrl
+        self.description = description
+    
+    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
+    
+    
+    @property
+    def imageUrl(self) -> Union[None, 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
+    
+    
+    @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
+    
+    
+class PageModuleScopeClass(object):
+    # No docs available.
+    
+    PERSONAL = "PERSONAL"
+    """This module is used for individual use only"""
+    
+    GLOBAL = "GLOBAL"
+    """This module is discoverable and can be used by any user on the platform"""
+    
+    
+    
+class RichTextModuleParamsClass(DictWrapper):
+    # No docs available.
+    
+    RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.module.RichTextModuleParams")
+    def __init__(self,
+        content: str,
+    ):
+        super().__init__()
+        
+        self.content = content
+    
+    def _restore_defaults(self) -> None:
+        self.content = str()
+    
+    
+    @property
+    def content(self) -> str:
+        # No docs available.
+        return self._inner_dict.get('content')  # type: ignore
+    
+    @content.setter
+    def content(self, value: str) -> None:
+        self._inner_dict['content'] = value
+    
+    
 class AssertionEvaluationContextClass(DictWrapper):
     """Additional context about assertion being evaluated."""
     
@@ -30107,6 +31713,8 @@ 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__()
         
@@ -30130,6 +31738,8 @@ 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
@@ -30140,6 +31750,8 @@ 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
@@ -30224,6 +31836,26 @@ 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"""
     
@@ -34184,6 +35816,59 @@ class NotificationSettingValueClass(object):
     
     
     
+class ApplicationsSettingsClass(DictWrapper):
+    # No docs available.
+    
+    RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.settings.global.ApplicationsSettings")
+    def __init__(self,
+        enabled: bool,
+        config: Union[None, str]=None,
+        configVersion: Union[None, str]=None,
+    ):
+        super().__init__()
+        
+        self.enabled = enabled
+        self.config = config
+        self.configVersion = configVersion
+    
+    def _restore_defaults(self) -> None:
+        self.enabled = bool()
+        self.config = self.RECORD_SCHEMA.fields_dict["config"].default
+        self.configVersion = self.RECORD_SCHEMA.fields_dict["configVersion"].default
+    
+    
+    @property
+    def enabled(self) -> bool:
+        # No docs available.
+        return self._inner_dict.get('enabled')  # type: ignore
+    
+    @enabled.setter
+    def enabled(self, value: bool) -> None:
+        self._inner_dict['enabled'] = value
+    
+    
+    @property
+    def config(self) -> Union[None, str]:
+        """The configuration for the feature, in JSON format."""
+        return self._inner_dict.get('config')  # type: ignore
+    
+    @config.setter
+    def config(self, value: Union[None, str]) -> None:
+        self._inner_dict['config'] = value
+    
+    
+    @property
+    def configVersion(self) -> Union[None, str]:
+        """The version of the configuration schema that has been used to serialize
+           the config.
+    If not provided, the version is assumed to be the latest version."""
+        return self._inner_dict.get('configVersion')  # type: ignore
+    
+    @configVersion.setter
+    def configVersion(self, value: Union[None, str]) -> None:
+        self._inner_dict['configVersion'] = value
+    
+    
 class DocPropagationFeatureSettingsClass(DictWrapper):
     # No docs available.
     
@@ -34308,6 +35993,31 @@ class EmailIntegrationSettingsClass(DictWrapper):
         self._inner_dict['defaultEmail'] = value
     
     
+class GlobalHomePageSettingsClass(DictWrapper):
+    """Global settings related to the home page for an instance"""
+    
+    RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.settings.global.GlobalHomePageSettings")
+    def __init__(self,
+        defaultTemplate: str,
+    ):
+        super().__init__()
+        
+        self.defaultTemplate = defaultTemplate
+    
+    def _restore_defaults(self) -> None:
+        self.defaultTemplate = str()
+    
+    
+    @property
+    def defaultTemplate(self) -> str:
+        """The urn that will be rendered in the UI by default for all users"""
+        return self._inner_dict.get('defaultTemplate')  # type: ignore
+    
+    @defaultTemplate.setter
+    def defaultTemplate(self, value: str) -> None:
+        self._inner_dict['defaultTemplate'] = value
+    
+    
 class GlobalIncidentsSettingsClass(DictWrapper):
     # No docs available.
     
@@ -34441,6 +36151,8 @@ class GlobalSettingsInfoClass(_Aspect):
         sso: Union[None, "SsoSettingsClass"]=None,
         views: Union[None, "GlobalViewsSettingsClass"]=None,
         docPropagation: Optional[Union["DocPropagationFeatureSettingsClass", None]]=None,
+        homePage: Union[None, "GlobalHomePageSettingsClass"]=None,
+        applications: Union[None, "ApplicationsSettingsClass"]=None,
         documentationAi: Union[None, "DocumentationAiSettingsClass"]=None,
         visual: Union[None, "GlobalVisualSettingsClass"]=None,
     ):
@@ -34455,6 +36167,8 @@ class GlobalSettingsInfoClass(_Aspect):
             self.docPropagation = _json_converter.from_json_object(self.RECORD_SCHEMA.fields_dict["docPropagation"].default, writers_schema=self.RECORD_SCHEMA.fields_dict["docPropagation"].type)
         else:
             self.docPropagation = docPropagation
+        self.homePage = homePage
+        self.applications = applications
         self.documentationAi = documentationAi
         self.visual = visual
     
@@ -34464,6 +36178,8 @@ class GlobalSettingsInfoClass(_Aspect):
         self.sso = self.RECORD_SCHEMA.fields_dict["sso"].default
         self.views = self.RECORD_SCHEMA.fields_dict["views"].default
         self.docPropagation = _json_converter.from_json_object(self.RECORD_SCHEMA.fields_dict["docPropagation"].default, writers_schema=self.RECORD_SCHEMA.fields_dict["docPropagation"].type)
+        self.homePage = self.RECORD_SCHEMA.fields_dict["homePage"].default
+        self.applications = self.RECORD_SCHEMA.fields_dict["applications"].default
         self.documentationAi = self.RECORD_SCHEMA.fields_dict["documentationAi"].default
         self.visual = self.RECORD_SCHEMA.fields_dict["visual"].default
     
@@ -34518,6 +36234,26 @@ class GlobalSettingsInfoClass(_Aspect):
         self._inner_dict['docPropagation'] = value
     
     
+    @property
+    def homePage(self) -> Union[None, "GlobalHomePageSettingsClass"]:
+        """Global settings related to the home page for an instance"""
+        return self._inner_dict.get('homePage')  # type: ignore
+    
+    @homePage.setter
+    def homePage(self, value: Union[None, "GlobalHomePageSettingsClass"]) -> None:
+        self._inner_dict['homePage'] = value
+    
+    
+    @property
+    def applications(self) -> Union[None, "ApplicationsSettingsClass"]:
+        """Settings related to applications. If not enabled, applications won't show up in navigation"""
+        return self._inner_dict.get('applications')  # type: ignore
+    
+    @applications.setter
+    def applications(self, value: Union[None, "ApplicationsSettingsClass"]) -> None:
+        self._inner_dict['applications'] = value
+    
+    
     @property
     def documentationAi(self) -> Union[None, "DocumentationAiSettingsClass"]:
         """Settings related to AI-powered documentation."""
@@ -34932,6 +36668,7 @@ class SlackIntegrationSettingsClass(DictWrapper):
         enabled: Optional[bool]=None,
         encryptedBotToken: Union[None, str]=None,
         defaultChannelName: Union[None, str]=None,
+        datahubAtMentionEnabled: Union[None, bool]=None,
     ):
         super().__init__()
         
@@ -34942,11 +36679,13 @@ 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
@@ -34982,6 +36721,17 @@ 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."""
     
@@ -35955,6 +37705,181 @@ class TelemetryClientIdClass(_Aspect):
         self._inner_dict['clientId'] = value
     
     
+class DataHubPageTemplatePropertiesClass(_Aspect):
+    """The main properties of a DataHub page template"""
+
+
+    ASPECT_NAME = 'dataHubPageTemplateProperties'
+    ASPECT_INFO = {}
+    RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.template.DataHubPageTemplateProperties")
+
+    def __init__(self,
+        rows: List["DataHubPageTemplateRowClass"],
+        surface: "DataHubPageTemplateSurfaceClass",
+        visibility: "DataHubPageTemplateVisibilityClass",
+        created: "AuditStampClass",
+        lastModified: "AuditStampClass",
+    ):
+        super().__init__()
+        
+        self.rows = rows
+        self.surface = surface
+        self.visibility = visibility
+        self.created = created
+        self.lastModified = lastModified
+    
+    def _restore_defaults(self) -> None:
+        self.rows = list()
+        self.surface = DataHubPageTemplateSurfaceClass._construct_with_defaults()
+        self.visibility = DataHubPageTemplateVisibilityClass._construct_with_defaults()
+        self.created = AuditStampClass._construct_with_defaults()
+        self.lastModified = AuditStampClass._construct_with_defaults()
+    
+    
+    @property
+    def rows(self) -> List["DataHubPageTemplateRowClass"]:
+        """The rows of modules contained in this template"""
+        return self._inner_dict.get('rows')  # type: ignore
+    
+    @rows.setter
+    def rows(self, value: List["DataHubPageTemplateRowClass"]) -> None:
+        self._inner_dict['rows'] = value
+    
+    
+    @property
+    def surface(self) -> "DataHubPageTemplateSurfaceClass":
+        """Info about the surface area of the product that this template is deployed in"""
+        return self._inner_dict.get('surface')  # type: ignore
+    
+    @surface.setter
+    def surface(self, value: "DataHubPageTemplateSurfaceClass") -> None:
+        self._inner_dict['surface'] = value
+    
+    
+    @property
+    def visibility(self) -> "DataHubPageTemplateVisibilityClass":
+        """Info about the visibility of this template"""
+        return self._inner_dict.get('visibility')  # type: ignore
+    
+    @visibility.setter
+    def visibility(self, value: "DataHubPageTemplateVisibilityClass") -> None:
+        self._inner_dict['visibility'] = value
+    
+    
+    @property
+    def created(self) -> "AuditStampClass":
+        """Audit stamp for when and by whom this template was created"""
+        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 for when and by whom this template was last updated"""
+        return self._inner_dict.get('lastModified')  # type: ignore
+    
+    @lastModified.setter
+    def lastModified(self, value: "AuditStampClass") -> None:
+        self._inner_dict['lastModified'] = value
+    
+    
+class DataHubPageTemplateRowClass(DictWrapper):
+    """A row of modules contained in a template"""
+    
+    RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.template.DataHubPageTemplateRow")
+    def __init__(self,
+        modules: List[str],
+    ):
+        super().__init__()
+        
+        self.modules = modules
+    
+    def _restore_defaults(self) -> None:
+        self.modules = list()
+    
+    
+    @property
+    def modules(self) -> List[str]:
+        """The modules that exist in this template row"""
+        return self._inner_dict.get('modules')  # type: ignore
+    
+    @modules.setter
+    def modules(self, value: List[str]) -> None:
+        self._inner_dict['modules'] = value
+    
+    
+class DataHubPageTemplateSurfaceClass(DictWrapper):
+    """Info about the surface area of the product that this template is deployed in"""
+    
+    RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.template.DataHubPageTemplateSurface")
+    def __init__(self,
+        surfaceType: Union[str, "PageTemplateSurfaceTypeClass"],
+    ):
+        super().__init__()
+        
+        self.surfaceType = surfaceType
+    
+    def _restore_defaults(self) -> None:
+        self.surfaceType = PageTemplateSurfaceTypeClass.HOME_PAGE
+    
+    
+    @property
+    def surfaceType(self) -> Union[str, "PageTemplateSurfaceTypeClass"]:
+        """Where exactly is this template being used"""
+        return self._inner_dict.get('surfaceType')  # type: ignore
+    
+    @surfaceType.setter
+    def surfaceType(self, value: Union[str, "PageTemplateSurfaceTypeClass"]) -> None:
+        self._inner_dict['surfaceType'] = value
+    
+    
+class DataHubPageTemplateVisibilityClass(DictWrapper):
+    """Info about the visibility of this template"""
+    
+    RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.template.DataHubPageTemplateVisibility")
+    def __init__(self,
+        scope: Union[str, "PageTemplateScopeClass"],
+    ):
+        super().__init__()
+        
+        self.scope = scope
+    
+    def _restore_defaults(self) -> None:
+        self.scope = PageTemplateScopeClass.PERSONAL
+    
+    
+    @property
+    def scope(self) -> Union[str, "PageTemplateScopeClass"]:
+        """The scope of this template and who can use/see it"""
+        return self._inner_dict.get('scope')  # type: ignore
+    
+    @scope.setter
+    def scope(self, value: Union[str, "PageTemplateScopeClass"]) -> None:
+        self._inner_dict['scope'] = value
+    
+    
+class PageTemplateScopeClass(object):
+    # No docs available.
+    
+    PERSONAL = "PERSONAL"
+    """This template is used for individual use only"""
+    
+    GLOBAL = "GLOBAL"
+    """This template is used across users"""
+    
+    
+    
+class PageTemplateSurfaceTypeClass(object):
+    # No docs available.
+    
+    HOME_PAGE = "HOME_PAGE"
+    """This template applies to what to display on the home page for users."""
+    
+    
+    
 class BatchTestRunEventClass(_Aspect):
     """An event representing the current status of evaluating a batch metadata test (run offline)"""
 
@@ -37647,6 +39572,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,
@@ -37674,6 +39619,7 @@ __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,
@@ -37962,6 +39908,7 @@ __SCHEMA_TYPES = {
     'com.linkedin.pegasus2avro.identity.CorpUserAppearanceSettings': CorpUserAppearanceSettingsClass,
     'com.linkedin.pegasus2avro.identity.CorpUserCredentials': CorpUserCredentialsClass,
     'com.linkedin.pegasus2avro.identity.CorpUserEditableInfo': CorpUserEditableInfoClass,
+    'com.linkedin.pegasus2avro.identity.CorpUserHomePageSettings': CorpUserHomePageSettingsClass,
     'com.linkedin.pegasus2avro.identity.CorpUserInfo': CorpUserInfoClass,
     'com.linkedin.pegasus2avro.identity.CorpUserSettings': CorpUserSettingsClass,
     'com.linkedin.pegasus2avro.identity.CorpUserStatus': CorpUserStatusClass,
@@ -38004,7 +39951,9 @@ __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,
@@ -38021,6 +39970,8 @@ __SCHEMA_TYPES = {
     'com.linkedin.pegasus2avro.metadata.key.DataHubIngestionSourceKey': DataHubIngestionSourceKeyClass,
     'com.linkedin.pegasus2avro.metadata.key.DataHubMetricCubeKey': DataHubMetricCubeKeyClass,
     'com.linkedin.pegasus2avro.metadata.key.DataHubOpenAPISchemaKey': DataHubOpenAPISchemaKeyClass,
+    'com.linkedin.pegasus2avro.metadata.key.DataHubPageModuleKey': DataHubPageModuleKeyClass,
+    'com.linkedin.pegasus2avro.metadata.key.DataHubPageTemplateKey': DataHubPageTemplateKeyClass,
     'com.linkedin.pegasus2avro.metadata.key.DataHubPersonaKey': DataHubPersonaKeyClass,
     'com.linkedin.pegasus2avro.metadata.key.DataHubPolicyKey': DataHubPolicyKeyClass,
     'com.linkedin.pegasus2avro.metadata.key.DataHubRetentionKey': DataHubRetentionKeyClass,
@@ -38145,6 +40096,15 @@ __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,
     'com.linkedin.pegasus2avro.monitor.AssertionEvaluationContext': AssertionEvaluationContextClass,
     'com.linkedin.pegasus2avro.monitor.AssertionEvaluationParameters': AssertionEvaluationParametersClass,
     'com.linkedin.pegasus2avro.monitor.AssertionEvaluationParametersType': AssertionEvaluationParametersTypeClass,
@@ -38270,9 +40230,11 @@ __SCHEMA_TYPES = {
     'com.linkedin.pegasus2avro.secret.DataHubSecretValue': DataHubSecretValueClass,
     'com.linkedin.pegasus2avro.settings.NotificationSetting': NotificationSettingClass,
     'com.linkedin.pegasus2avro.settings.NotificationSettingValue': NotificationSettingValueClass,
+    'com.linkedin.pegasus2avro.settings.global.ApplicationsSettings': ApplicationsSettingsClass,
     'com.linkedin.pegasus2avro.settings.global.DocPropagationFeatureSettings': DocPropagationFeatureSettingsClass,
     'com.linkedin.pegasus2avro.settings.global.DocumentationAiSettings': DocumentationAiSettingsClass,
     'com.linkedin.pegasus2avro.settings.global.EmailIntegrationSettings': EmailIntegrationSettingsClass,
+    'com.linkedin.pegasus2avro.settings.global.GlobalHomePageSettings': GlobalHomePageSettingsClass,
     'com.linkedin.pegasus2avro.settings.global.GlobalIncidentsSettings': GlobalIncidentsSettingsClass,
     'com.linkedin.pegasus2avro.settings.global.GlobalIntegrationSettings': GlobalIntegrationSettingsClass,
     'com.linkedin.pegasus2avro.settings.global.GlobalNotificationSettings': GlobalNotificationSettingsClass,
@@ -38300,6 +40262,12 @@ __SCHEMA_TYPES = {
     'com.linkedin.pegasus2avro.subscription.SubscriptionType': SubscriptionTypeClass,
     'com.linkedin.pegasus2avro.tag.TagProperties': TagPropertiesClass,
     'com.linkedin.pegasus2avro.telemetry.TelemetryClientId': TelemetryClientIdClass,
+    'com.linkedin.pegasus2avro.template.DataHubPageTemplateProperties': DataHubPageTemplatePropertiesClass,
+    'com.linkedin.pegasus2avro.template.DataHubPageTemplateRow': DataHubPageTemplateRowClass,
+    'com.linkedin.pegasus2avro.template.DataHubPageTemplateSurface': DataHubPageTemplateSurfaceClass,
+    'com.linkedin.pegasus2avro.template.DataHubPageTemplateVisibility': DataHubPageTemplateVisibilityClass,
+    'com.linkedin.pegasus2avro.template.PageTemplateScope': PageTemplateScopeClass,
+    'com.linkedin.pegasus2avro.template.PageTemplateSurfaceType': PageTemplateSurfaceTypeClass,
     'com.linkedin.pegasus2avro.test.BatchTestRunEvent': BatchTestRunEventClass,
     'com.linkedin.pegasus2avro.test.BatchTestRunResult': BatchTestRunResultClass,
     'com.linkedin.pegasus2avro.test.BatchTestRunStatus': BatchTestRunStatusClass,
@@ -38364,6 +40332,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,
@@ -38391,6 +40379,7 @@ __SCHEMA_TYPES = {
     'AssertionInfo': AssertionInfoClass,
     'AssertionMetric': AssertionMetricClass,
     'AssertionMonitorSensitivity': AssertionMonitorSensitivityClass,
+    'AssertionNote': AssertionNoteClass,
     'AssertionResult': AssertionResultClass,
     'AssertionResultError': AssertionResultErrorClass,
     'AssertionResultErrorType': AssertionResultErrorTypeClass,
@@ -38679,6 +40668,7 @@ __SCHEMA_TYPES = {
     'CorpUserAppearanceSettings': CorpUserAppearanceSettingsClass,
     'CorpUserCredentials': CorpUserCredentialsClass,
     'CorpUserEditableInfo': CorpUserEditableInfoClass,
+    'CorpUserHomePageSettings': CorpUserHomePageSettingsClass,
     'CorpUserInfo': CorpUserInfoClass,
     'CorpUserSettings': CorpUserSettingsClass,
     'CorpUserStatus': CorpUserStatusClass,
@@ -38721,7 +40711,9 @@ __SCHEMA_TYPES = {
     'DataHubIngestionSourceSourceType': DataHubIngestionSourceSourceTypeClass,
     'LinkPreviewInfo': LinkPreviewInfoClass,
     'LinkPreviewType': LinkPreviewTypeClass,
+    'LogicalParent': LogicalParentClass,
     'ActionRequestKey': ActionRequestKeyClass,
+    'ActionWorkflowKey': ActionWorkflowKeyClass,
     'AnomalyKey': AnomalyKeyClass,
     'AssertionKey': AssertionKeyClass,
     'ChartKey': ChartKeyClass,
@@ -38738,6 +40730,8 @@ __SCHEMA_TYPES = {
     'DataHubIngestionSourceKey': DataHubIngestionSourceKeyClass,
     'DataHubMetricCubeKey': DataHubMetricCubeKeyClass,
     'DataHubOpenAPISchemaKey': DataHubOpenAPISchemaKeyClass,
+    'DataHubPageModuleKey': DataHubPageModuleKeyClass,
+    'DataHubPageTemplateKey': DataHubPageTemplateKeyClass,
     'DataHubPersonaKey': DataHubPersonaKeyClass,
     'DataHubPolicyKey': DataHubPolicyKeyClass,
     'DataHubRetentionKey': DataHubRetentionKeyClass,
@@ -38862,6 +40856,15 @@ __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,
     'AssertionEvaluationContext': AssertionEvaluationContextClass,
     'AssertionEvaluationParameters': AssertionEvaluationParametersClass,
     'AssertionEvaluationParametersType': AssertionEvaluationParametersTypeClass,
@@ -38987,9 +40990,11 @@ __SCHEMA_TYPES = {
     'DataHubSecretValue': DataHubSecretValueClass,
     'NotificationSetting': NotificationSettingClass,
     'NotificationSettingValue': NotificationSettingValueClass,
+    'ApplicationsSettings': ApplicationsSettingsClass,
     'DocPropagationFeatureSettings': DocPropagationFeatureSettingsClass,
     'DocumentationAiSettings': DocumentationAiSettingsClass,
     'EmailIntegrationSettings': EmailIntegrationSettingsClass,
+    'GlobalHomePageSettings': GlobalHomePageSettingsClass,
     'GlobalIncidentsSettings': GlobalIncidentsSettingsClass,
     'GlobalIntegrationSettings': GlobalIntegrationSettingsClass,
     'GlobalNotificationSettings': GlobalNotificationSettingsClass,
@@ -39017,6 +41022,12 @@ __SCHEMA_TYPES = {
     'SubscriptionType': SubscriptionTypeClass,
     'TagProperties': TagPropertiesClass,
     'TelemetryClientId': TelemetryClientIdClass,
+    'DataHubPageTemplateProperties': DataHubPageTemplatePropertiesClass,
+    'DataHubPageTemplateRow': DataHubPageTemplateRowClass,
+    'DataHubPageTemplateSurface': DataHubPageTemplateSurfaceClass,
+    'DataHubPageTemplateVisibility': DataHubPageTemplateVisibilityClass,
+    'PageTemplateScope': PageTemplateScopeClass,
+    'PageTemplateSurfaceType': PageTemplateSurfaceTypeClass,
     'BatchTestRunEvent': BatchTestRunEventClass,
     'BatchTestRunResult': BatchTestRunResultClass,
     'BatchTestRunStatus': BatchTestRunStatusClass,
@@ -39136,7 +41147,9 @@ ASPECT_CLASSES: List[Type[_Aspect]] = [
     CorpGroupKeyClass,
     VersionSetKeyClass,
     AnomalyKeyClass,
+    ActionWorkflowKeyClass,
     ChartKeyClass,
+    DataHubPageTemplateKeyClass,
     OwnershipTypeKeyClass,
     RemoteExecutorPoolKeyClass,
     GenericEntityKeyClass,
@@ -39171,6 +41184,7 @@ ASPECT_CLASSES: List[Type[_Aspect]] = [
     GlobalSettingsKeyClass,
     RemoteExecutorGlobalConfigKeyClass,
     ContainerKeyClass,
+    DataHubPageModuleKeyClass,
     LineageFeaturesClass,
     StorageFeaturesClass,
     UsageFeaturesClass,
@@ -39224,6 +41238,7 @@ ASPECT_CLASSES: List[Type[_Aspect]] = [
     BusinessAttributeInfoClass,
     BusinessAttributeKeyClass,
     BusinessAttributesClass,
+    LogicalParentClass,
     LinkPreviewInfoClass,
     GlobalSettingsInfoClass,
     TelemetryClientIdClass,
@@ -39291,6 +41306,7 @@ ASPECT_CLASSES: List[Type[_Aspect]] = [
     DataContractPropertiesClass,
     DataContractStatusClass,
     MonitorAnomalyEventClass,
+    ActionWorkflowInfoClass,
     DataHubIngestionSourceInfoClass,
     GlossaryTermInfoClass,
     GlossaryNodeInfoClass,
@@ -39311,6 +41327,7 @@ ASPECT_CLASSES: List[Type[_Aspect]] = [
     DataProcessInstanceRelationshipsClass,
     DataProcessInstancePropertiesClass,
     RemoteExecutorPoolGlobalConfigClass,
+    DataHubPageTemplatePropertiesClass,
     InferredMetadataClass,
     SchemaFieldsInferredMetadataClass,
     InferredNeighborsClass,
@@ -39326,6 +41343,7 @@ ASPECT_CLASSES: List[Type[_Aspect]] = [
     StructuredPropertySettingsClass,
     StructuredPropertiesClass,
     StructuredPropertyDefinitionClass,
+    DataHubPageModulePropertiesClass,
     ExecutionRequestResultClass,
     ExecutionRequestInputClass,
     ExecutionRequestSignalClass,
@@ -39348,7 +41366,7 @@ ASPECT_NAME_MAP: Dict[str, Type[_Aspect]] = {
     for aspect in ASPECT_CLASSES
 }
 
-from typing import Literal
+from typing import Literal, Set
 from typing_extensions import TypedDict
 
 class AspectBag(TypedDict, total=False):
@@ -39423,7 +41441,9 @@ class AspectBag(TypedDict, total=False):
     corpGroupKey: CorpGroupKeyClass
     versionSetKey: VersionSetKeyClass
     anomalyKey: AnomalyKeyClass
+    actionWorkflowKey: ActionWorkflowKeyClass
     chartKey: ChartKeyClass
+    dataHubPageTemplateKey: DataHubPageTemplateKeyClass
     ownershipTypeKey: OwnershipTypeKeyClass
     dataHubRemoteExecutorPoolKey: RemoteExecutorPoolKeyClass
     genericEntityKey: GenericEntityKeyClass
@@ -39458,6 +41478,7 @@ class AspectBag(TypedDict, total=False):
     globalSettingsKey: GlobalSettingsKeyClass
     dataHubRemoteExecutorGlobalConfigKey: RemoteExecutorGlobalConfigKeyClass
     containerKey: ContainerKeyClass
+    dataHubPageModuleKey: DataHubPageModuleKeyClass
     lineageFeatures: LineageFeaturesClass
     storageFeatures: StorageFeaturesClass
     usageFeatures: UsageFeaturesClass
@@ -39511,6 +41532,7 @@ class AspectBag(TypedDict, total=False):
     businessAttributeInfo: BusinessAttributeInfoClass
     businessAttributeKey: BusinessAttributeKeyClass
     businessAttributes: BusinessAttributesClass
+    logicalParent: LogicalParentClass
     linkPreviewInfo: LinkPreviewInfoClass
     globalSettingsInfo: GlobalSettingsInfoClass
     telemetryClientId: TelemetryClientIdClass
@@ -39578,6 +41600,7 @@ class AspectBag(TypedDict, total=False):
     dataContractProperties: DataContractPropertiesClass
     dataContractStatus: DataContractStatusClass
     monitorAnomalyEvent: MonitorAnomalyEventClass
+    actionWorkflowInfo: ActionWorkflowInfoClass
     dataHubIngestionSourceInfo: DataHubIngestionSourceInfoClass
     glossaryTermInfo: GlossaryTermInfoClass
     glossaryNodeInfo: GlossaryNodeInfoClass
@@ -39598,6 +41621,7 @@ class AspectBag(TypedDict, total=False):
     dataProcessInstanceRelationships: DataProcessInstanceRelationshipsClass
     dataProcessInstanceProperties: DataProcessInstancePropertiesClass
     dataHubRemoteExecutorPoolGlobalConfig: RemoteExecutorPoolGlobalConfigClass
+    dataHubPageTemplateProperties: DataHubPageTemplatePropertiesClass
     inferredMetadata: InferredMetadataClass
     schemaFieldsInferredMetadata: SchemaFieldsInferredMetadataClass
     inferredNeighbors: InferredNeighborsClass
@@ -39613,6 +41637,7 @@ class AspectBag(TypedDict, total=False):
     structuredPropertySettings: StructuredPropertySettingsClass
     structuredProperties: StructuredPropertiesClass
     propertyDefinition: StructuredPropertyDefinitionClass
+    dataHubPageModuleProperties: DataHubPageModulePropertiesClass
     dataHubExecutionRequestResult: ExecutionRequestResultClass
     dataHubExecutionRequestInput: ExecutionRequestInputClass
     dataHubExecutionRequestSignal: ExecutionRequestSignalClass
@@ -39662,7 +41687,9 @@ KEY_ASPECTS: Dict[str, Type[_Aspect]] = {
     'mlPrimaryKey': MLPrimaryKeyKeyClass,
     'corpGroup': CorpGroupKeyClass,
     'versionSet': VersionSetKeyClass,
+    'actionWorkflow': ActionWorkflowKeyClass,
     'chart': ChartKeyClass,
+    'dataHubPageTemplate': DataHubPageTemplateKeyClass,
     'ownershipType': OwnershipTypeKeyClass,
     'dataHubRemoteExecutorPool': RemoteExecutorPoolKeyClass,
     'telemetry': TelemetryKeyClass,
@@ -39696,6 +41723,7 @@ KEY_ASPECTS: Dict[str, Type[_Aspect]] = {
     'globalSettings': GlobalSettingsKeyClass,
     'dataHubRemoteExecutorGlobalConfig': RemoteExecutorGlobalConfigKeyClass,
     'container': ContainerKeyClass,
+    'dataHubPageModule': DataHubPageModuleKeyClass,
     'entityType': EntityTypeKeyClass,
     'dataProduct': DataProductKeyClass,
     'application': ApplicationKeyClass,
@@ -39703,6 +41731,8 @@ KEY_ASPECTS: Dict[str, Type[_Aspect]] = {
     'structuredProperty': StructuredPropertyKeyClass
 }
 
+KEY_ASPECT_NAMES: Set[str] = {cls.ASPECT_NAME for cls in KEY_ASPECTS.values()}
+
 ENTITY_TYPE_NAMES: List[str] = [
     'platformResource',
     'dataType',
@@ -39735,7 +41765,9 @@ ENTITY_TYPE_NAMES: List[str] = [
     'mlPrimaryKey',
     'corpGroup',
     'versionSet',
+    'actionWorkflow',
     'chart',
+    'dataHubPageTemplate',
     'ownershipType',
     'dataHubRemoteExecutorPool',
     'telemetry',
@@ -39769,6 +41801,7 @@ ENTITY_TYPE_NAMES: List[str] = [
     'globalSettings',
     'dataHubRemoteExecutorGlobalConfig',
     'container',
+    'dataHubPageModule',
     'entityType',
     'dataProduct',
     'application',
@@ -39807,7 +41840,9 @@ EntityTypeName = Literal[
     'mlPrimaryKey',
     'corpGroup',
     'versionSet',
+    'actionWorkflow',
     'chart',
+    'dataHubPageTemplate',
     'ownershipType',
     'dataHubRemoteExecutorPool',
     'telemetry',
@@ -39841,6 +41876,7 @@ EntityTypeName = Literal[
     'globalSettings',
     'dataHubRemoteExecutorGlobalConfig',
     'container',
+    'dataHubPageModule',
     'entityType',
     'dataProduct',
     'application',