acryl-datahub-cloud 0.3.13.2rc4__py3-none-any.whl → 0.3.14rc0__py3-none-any.whl

acryl_datahub_cloud/metadata/schema_classes.py

@@ -3280,7 +3280,6 @@ class AssertionAnalyticsRunEventClass(_Aspect):
         asserteeGlossaryTerms: Union[None, List[str]]=None,
         asserteeOwners: Union[None, List[str]]=None,
         asserteeDataPlatform: Union[None, str]=None,
-        asserteeContainer: Union[None, str]=None,
         asserteeDataPlatformInstance: Union[None, str]=None,
         asserteeSchemaFieldGlossaryTerms: Union[None, List[str]]=None,
         asserteeSchemaFieldTags: Union[None, List[str]]=None,
@@ -3299,7 +3298,6 @@ class AssertionAnalyticsRunEventClass(_Aspect):
         self.asserteeGlossaryTerms = asserteeGlossaryTerms
         self.asserteeOwners = asserteeOwners
         self.asserteeDataPlatform = asserteeDataPlatform
-        self.asserteeContainer = asserteeContainer
         self.asserteeDataPlatformInstance = asserteeDataPlatformInstance
         self.asserteeSchemaFieldGlossaryTerms = asserteeSchemaFieldGlossaryTerms
         self.asserteeSchemaFieldTags = asserteeSchemaFieldTags
@@ -3326,7 +3324,6 @@ class AssertionAnalyticsRunEventClass(_Aspect):
         self.asserteeGlossaryTerms = self.RECORD_SCHEMA.fields_dict["asserteeGlossaryTerms"].default
         self.asserteeOwners = self.RECORD_SCHEMA.fields_dict["asserteeOwners"].default
         self.asserteeDataPlatform = self.RECORD_SCHEMA.fields_dict["asserteeDataPlatform"].default
-        self.asserteeContainer = self.RECORD_SCHEMA.fields_dict["asserteeContainer"].default
         self.asserteeDataPlatformInstance = self.RECORD_SCHEMA.fields_dict["asserteeDataPlatformInstance"].default
         self.asserteeSchemaFieldGlossaryTerms = self.RECORD_SCHEMA.fields_dict["asserteeSchemaFieldGlossaryTerms"].default
         self.asserteeSchemaFieldTags = self.RECORD_SCHEMA.fields_dict["asserteeSchemaFieldTags"].default
@@ -3422,16 +3419,6 @@ class AssertionAnalyticsRunEventClass(_Aspect):
         self._inner_dict['asserteeDataPlatform'] = value
     
     
-    @property
-    def asserteeContainer(self) -> Union[None, str]:
-        """The Container attached to the entity's parent Asset"""
-        return self._inner_dict.get('asserteeContainer')  # type: ignore
-    
-    @asserteeContainer.setter
-    def asserteeContainer(self, value: Union[None, str]) -> None:
-        self._inner_dict['asserteeContainer'] = value
-    
-    
     @property
     def asserteeDataPlatformInstance(self) -> Union[None, str]:
         """Instance of the parent's data platform (e.g. db instance)"""
@@ -10418,6 +10405,7 @@ class OwnerClass(DictWrapper):
         type: Union[str, "OwnershipTypeClass"],
         typeUrn: Union[None, str]=None,
         source: Union[None, "OwnershipSourceClass"]=None,
+        attribution: Union[None, "MetadataAttributionClass"]=None,
     ):
         super().__init__()
         
@@ -10425,12 +10413,14 @@ class OwnerClass(DictWrapper):
         self.type = type
         self.typeUrn = typeUrn
         self.source = source
+        self.attribution = attribution
     
     def _restore_defaults(self) -> None:
         self.owner = str()
         self.type = OwnershipTypeClass.CUSTOM
         self.typeUrn = self.RECORD_SCHEMA.fields_dict["typeUrn"].default
         self.source = self.RECORD_SCHEMA.fields_dict["source"].default
+        self.attribution = self.RECORD_SCHEMA.fields_dict["attribution"].default
     
     
     @property
@@ -10475,6 +10465,16 @@ class OwnerClass(DictWrapper):
         self._inner_dict['source'] = value
     
     
+    @property
+    def attribution(self) -> Union[None, "MetadataAttributionClass"]:
+        """Information about who, why, and how this metadata was applied"""
+        return self._inner_dict.get('attribution')  # type: ignore
+    
+    @attribution.setter
+    def attribution(self, value: Union[None, "MetadataAttributionClass"]) -> None:
+        self._inner_dict['attribution'] = value
+    
+    
 class OwnershipClass(_Aspect):
     """Ownership information of an entity."""
 
@@ -18618,6 +18618,9 @@ class NotificationTemplateTypeClass(object):
     BROADCAST_ASSERTION_STATUS_CHANGE = "BROADCAST_ASSERTION_STATUS_CHANGE"
     """Assertion change notification template."""
     
+    INVITATION = "INVITATION"
+    """User invitation notification template."""
+    
     CUSTOM = "CUSTOM"
     """Legacy template types to support backwards compatibility."""
     
@@ -21239,6 +21242,87 @@ class CorpUserInfoClass(_Aspect):
         self._inner_dict['system'] = value
     
     
+class CorpUserInvitationStatusClass(_Aspect):
+    # No docs available.
+
+
+    ASPECT_NAME = 'corpUserInvitationStatus'
+    ASPECT_INFO = {}
+    RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.identity.CorpUserInvitationStatus")
+
+    def __init__(self,
+        created: "AuditStampClass",
+        status: Union[str, "InvitationStatusClass"],
+        lastUpdated: "AuditStampClass",
+        invitationToken: str,
+        role: Union[None, str]=None,
+    ):
+        super().__init__()
+        
+        self.role = role
+        self.created = created
+        self.status = status
+        self.lastUpdated = lastUpdated
+        self.invitationToken = invitationToken
+    
+    def _restore_defaults(self) -> None:
+        self.role = self.RECORD_SCHEMA.fields_dict["role"].default
+        self.created = AuditStampClass._construct_with_defaults()
+        self.status = InvitationStatusClass.SENT
+        self.lastUpdated = AuditStampClass._construct_with_defaults()
+        self.invitationToken = str()
+    
+    
+    @property
+    def role(self) -> Union[None, str]:
+        """Role will only work in non-sso environments today."""
+        return self._inner_dict.get('role')  # type: ignore
+    
+    @role.setter
+    def role(self, value: Union[None, str]) -> None:
+        self._inner_dict['role'] = value
+    
+    
+    @property
+    def created(self) -> "AuditStampClass":
+        """Created Audit"""
+        return self._inner_dict.get('created')  # type: ignore
+    
+    @created.setter
+    def created(self, value: "AuditStampClass") -> None:
+        self._inner_dict['created'] = value
+    
+    
+    @property
+    def status(self) -> Union[str, "InvitationStatusClass"]:
+        """The status of the invitation"""
+        return self._inner_dict.get('status')  # type: ignore
+    
+    @status.setter
+    def status(self, value: Union[str, "InvitationStatusClass"]) -> None:
+        self._inner_dict['status'] = value
+    
+    
+    @property
+    def lastUpdated(self) -> "AuditStampClass":
+        """Last Status Change Audit"""
+        return self._inner_dict.get('lastUpdated')  # type: ignore
+    
+    @lastUpdated.setter
+    def lastUpdated(self, value: "AuditStampClass") -> None:
+        self._inner_dict['lastUpdated'] = value
+    
+    
+    @property
+    def invitationToken(self) -> str:
+        """Unique token for the invitation URL - hashed via SecretService """
+        return self._inner_dict.get('invitationToken')  # type: ignore
+    
+    @invitationToken.setter
+    def invitationToken(self, value: str) -> None:
+        self._inner_dict['invitationToken'] = value
+    
+    
 class CorpUserSettingsClass(_Aspect):
     """Settings that a user can customize through the DataHub UI"""
 
@@ -21404,6 +21488,15 @@ class GroupMembershipClass(_Aspect):
         self._inner_dict['groups'] = value
     
     
+class InvitationStatusClass(object):
+    # No docs available.
+    
+    SENT = "SENT"
+    ACCEPTED = "ACCEPTED"
+    REVOKED = "REVOKED"
+    SUGGESTION_DISMISSED = "SUGGESTION_DISMISSED"
+    
+    
 class InviteTokenClass(_Aspect):
     """Aspect used to store invite tokens."""
 
@@ -21415,15 +21508,22 @@ class InviteTokenClass(_Aspect):
     def __init__(self,
         token: str,
         role: Union[None, str]=None,
+        tokenType: Optional[Union[Union[str, "TokenTypeClass"], None]]=None,
     ):
         super().__init__()
         
         self.token = token
         self.role = role
+        if tokenType is None:
+            # default: 'SHARED'
+            self.tokenType = self.RECORD_SCHEMA.fields_dict["tokenType"].default
+        else:
+            self.tokenType = tokenType
     
     def _restore_defaults(self) -> None:
         self.token = str()
         self.role = self.RECORD_SCHEMA.fields_dict["role"].default
+        self.tokenType = self.RECORD_SCHEMA.fields_dict["tokenType"].default
     
     
     @property
@@ -21446,6 +21546,16 @@ class InviteTokenClass(_Aspect):
         self._inner_dict['role'] = value
     
     
+    @property
+    def tokenType(self) -> Union[Union[str, "TokenTypeClass"], None]:
+        """The type of invite token - shared (admin managed) or individual (single-use)"""
+        return self._inner_dict.get('tokenType')  # type: ignore
+    
+    @tokenType.setter
+    def tokenType(self, value: Union[Union[str, "TokenTypeClass"], None]) -> None:
+        self._inner_dict['tokenType'] = value
+    
+    
 class NativeGroupMembershipClass(_Aspect):
     """Carries information about the native CorpGroups a user is in."""
 
@@ -21504,6 +21614,17 @@ class RoleMembershipClass(_Aspect):
         self._inner_dict['roles'] = value
     
     
+class TokenTypeClass(object):
+    """Token types for different invitation workflows"""
+    
+    SHARED = "SHARED"
+    """Shared token that admin can copy and share manually. Reusable until admin regenerates."""
+    
+    INDIVIDUAL = "INDIVIDUAL"
+    """Individual token generated for bulk invitations. Single-use, consumed on signup."""
+    
+    
+    
 class IncidentActivityChangeClass(DictWrapper):
     """Incident Activity Change is a record that represents the changes that occurred in the incident activity event."""
     
@@ -23062,23 +23183,23 @@ class LogicalParentClass(_Aspect):
     RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.logical.LogicalParent")
 
     def __init__(self,
-        parent: "EdgeClass",
+        parent: Union[None, "EdgeClass"]=None,
     ):
         super().__init__()
         
         self.parent = parent
     
     def _restore_defaults(self) -> None:
-        self.parent = EdgeClass._construct_with_defaults()
+        self.parent = self.RECORD_SCHEMA.fields_dict["parent"].default
     
     
     @property
-    def parent(self) -> "EdgeClass":
+    def parent(self) -> Union[None, "EdgeClass"]:
         # No docs available.
         return self._inner_dict.get('parent')  # type: ignore
     
     @parent.setter
-    def parent(self, value: "EdgeClass") -> None:
+    def parent(self, value: Union[None, "EdgeClass"]) -> None:
         self._inner_dict['parent'] = value
     
     
@@ -23332,7 +23453,7 @@ class CorpUserKeyClass(_Aspect):
 
 
     ASPECT_NAME = 'corpUserKey'
-    ASPECT_INFO = {'keyForEntity': 'corpuser', 'entityCategory': '_unset_', 'entityAspects': ['corpUserInfo', 'corpUserEditableInfo', 'corpUserStatus', 'groupMembership', 'globalTags', 'status', 'corpUserCredentials', 'nativeGroupMembership', 'corpUserSettings', 'origin', 'roleMembership', 'structuredProperties', 'forms', 'testResults', 'subTypes', 'slackUserInfo', 'share', 'formNotifications'], 'entityDoc': 'CorpUser represents an identity of a person (or an account) in the enterprise.'}
+    ASPECT_INFO = {'keyForEntity': 'corpuser', 'entityCategory': '_unset_', 'entityAspects': ['corpUserInfo', 'corpUserEditableInfo', 'corpUserStatus', 'groupMembership', 'globalTags', 'status', 'corpUserCredentials', 'nativeGroupMembership', 'corpUserSettings', 'origin', 'roleMembership', 'structuredProperties', 'forms', 'testResults', 'subTypes', 'slackUserInfo', 'corpUserUsageFeatures', 'corpUserInvitationStatus', 'share', 'formNotifications'], 'entityDoc': 'CorpUser represents an identity of a person (or an account) in the enterprise.'}
     RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.metadata.key.CorpUserKey")
 
     def __init__(self,
@@ -25190,7 +25311,7 @@ class SchemaFieldKeyClass(_Aspect):
 
 
     ASPECT_NAME = 'schemaFieldKey'
-    ASPECT_INFO = {'keyForEntity': 'schemaField', 'entityCategory': 'core', 'entityAspects': ['schemafieldInfo', 'structuredProperties', 'forms', 'businessAttributes', 'status', 'schemaFieldAliases', 'documentation', 'testResults', 'deprecation', 'subTypes', 'logicalParent', 'schemaFieldProfile', 'lineageFeatures']}
+    ASPECT_INFO = {'keyForEntity': 'schemaField', 'entityCategory': 'core', 'entityAspects': ['schemafieldInfo', 'structuredProperties', 'forms', 'businessAttributes', 'status', 'schemaFieldAliases', 'documentation', 'testResults', 'deprecation', 'subTypes', 'logicalParent', 'globalTags', 'glossaryTerms', 'schemaFieldProfile', 'lineageFeatures']}
     RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.metadata.key.SchemaFieldKey")
 
     def __init__(self,
@@ -25894,6 +26015,90 @@ class SearchParamsClass(DictWrapper):
         self._inner_dict['filters'] = value
     
     
+class CorpUserUsageFeaturesClass(_Aspect):
+    # No docs available.
+
+
+    ASPECT_NAME = 'corpUserUsageFeatures'
+    ASPECT_INFO = {}
+    RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.metadata.search.features.CorpUserUsageFeatures")
+
+    def __init__(self,
+        userUsageTotalPast30Days: Union[None, int]=None,
+        userPlatformUsageTotalsPast30Days: Union[None, Dict[str, float]]=None,
+        userPlatformUsagePercentilePast30Days: Union[None, Dict[str, float]]=None,
+        userUsagePercentilePast30Days: Union[None, float]=None,
+        userTopDatasetsByUsage: Union[None, Dict[str, float]]=None,
+    ):
+        super().__init__()
+        
+        self.userUsageTotalPast30Days = userUsageTotalPast30Days
+        self.userPlatformUsageTotalsPast30Days = userPlatformUsageTotalsPast30Days
+        self.userPlatformUsagePercentilePast30Days = userPlatformUsagePercentilePast30Days
+        self.userUsagePercentilePast30Days = userUsagePercentilePast30Days
+        self.userTopDatasetsByUsage = userTopDatasetsByUsage
+    
+    def _restore_defaults(self) -> None:
+        self.userUsageTotalPast30Days = self.RECORD_SCHEMA.fields_dict["userUsageTotalPast30Days"].default
+        self.userPlatformUsageTotalsPast30Days = self.RECORD_SCHEMA.fields_dict["userPlatformUsageTotalsPast30Days"].default
+        self.userPlatformUsagePercentilePast30Days = self.RECORD_SCHEMA.fields_dict["userPlatformUsagePercentilePast30Days"].default
+        self.userUsagePercentilePast30Days = self.RECORD_SCHEMA.fields_dict["userUsagePercentilePast30Days"].default
+        self.userTopDatasetsByUsage = self.RECORD_SCHEMA.fields_dict["userTopDatasetsByUsage"].default
+    
+    
+    @property
+    def userUsageTotalPast30Days(self) -> Union[None, int]:
+        """Total number of usage in the last 30 days"""
+        return self._inner_dict.get('userUsageTotalPast30Days')  # type: ignore
+    
+    @userUsageTotalPast30Days.setter
+    def userUsageTotalPast30Days(self, value: Union[None, int]) -> None:
+        self._inner_dict['userUsageTotalPast30Days'] = value
+    
+    
+    @property
+    def userPlatformUsageTotalsPast30Days(self) -> Union[None, Dict[str, float]]:
+        """usage broken down by platform so we can differentiate between top users of snowflake vs redshift
+    key is supposed to be platform urn"""
+        return self._inner_dict.get('userPlatformUsageTotalsPast30Days')  # type: ignore
+    
+    @userPlatformUsageTotalsPast30Days.setter
+    def userPlatformUsageTotalsPast30Days(self, value: Union[None, Dict[str, float]]) -> None:
+        self._inner_dict['userPlatformUsageTotalsPast30Days'] = value
+    
+    
+    @property
+    def userPlatformUsagePercentilePast30Days(self) -> Union[None, Dict[str, float]]:
+        """usage broken down by platform so we can differentiate between top users of snowflake vs redshift"""
+        return self._inner_dict.get('userPlatformUsagePercentilePast30Days')  # type: ignore
+    
+    @userPlatformUsagePercentilePast30Days.setter
+    def userPlatformUsagePercentilePast30Days(self, value: Union[None, Dict[str, float]]) -> None:
+        self._inner_dict['userPlatformUsagePercentilePast30Days'] = value
+    
+    
+    @property
+    def userUsagePercentilePast30Days(self) -> Union[None, float]:
+        """Platform usage total percentile for ranking users across all platforms"""
+        return self._inner_dict.get('userUsagePercentilePast30Days')  # type: ignore
+    
+    @userUsagePercentilePast30Days.setter
+    def userUsagePercentilePast30Days(self, value: Union[None, float]) -> None:
+        self._inner_dict['userUsagePercentilePast30Days'] = value
+    
+    
+    @property
+    def userTopDatasetsByUsage(self) -> Union[None, Dict[str, float]]:
+        """Gather what are the top datasets per user so we can create a welcome module
+    With links to the users top datasets with lineage (top 25)
+    Map keys are dataset URN strings"""
+        return self._inner_dict.get('userTopDatasetsByUsage')  # type: ignore
+    
+    @userTopDatasetsByUsage.setter
+    def userTopDatasetsByUsage(self, value: Union[None, Dict[str, float]]) -> None:
+        self._inner_dict['userTopDatasetsByUsage'] = value
+    
+    
 class CostCurrencyCodeClass(object):
     """ Currency code for the cost """
     
@@ -29445,13 +29650,16 @@ class AssetCollectionModuleParamsClass(DictWrapper):
     RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.module.AssetCollectionModuleParams")
     def __init__(self,
         assetUrns: List[str],
+        dynamicFilterJson: Union[None, str]=None,
     ):
         super().__init__()
         
         self.assetUrns = assetUrns
+        self.dynamicFilterJson = dynamicFilterJson
     
     def _restore_defaults(self) -> None:
         self.assetUrns = list()
+        self.dynamicFilterJson = self.RECORD_SCHEMA.fields_dict["dynamicFilterJson"].default
     
     
     @property
@@ -29464,6 +29672,20 @@ class AssetCollectionModuleParamsClass(DictWrapper):
         self._inner_dict['assetUrns'] = value
     
     
+    @property
+    def dynamicFilterJson(self) -> Union[None, str]:
+        """Optional dynamic filters
+    
+    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('dynamicFilterJson')  # type: ignore
+    
+    @dynamicFilterJson.setter
+    def dynamicFilterJson(self, value: Union[None, str]) -> None:
+        self._inner_dict['dynamicFilterJson'] = value
+    
+    
 class DataHubPageModuleParamsClass(DictWrapper):
     """The specific parameters stored for a module"""
     
@@ -29646,6 +29868,9 @@ class DataHubPageModuleTypeClass(object):
     SUBSCRIBED_ASSETS = "SUBSCRIBED_ASSETS"
     """Module displaying assets subscribed to by a given user"""
     
+    WORKFLOWS = "WORKFLOWS"
+    """Module displaying workflows that can be started"""
+    
     
     
 class DataHubPageModuleVisibilityClass(DictWrapper):
@@ -32663,6 +32888,153 @@ class ParametersClass(DictWrapper):
         pass
     
     
+class RelationshipChangeEventClass(DictWrapper):
+    """Kafka event for proposing a relationship change between two entities.
+    For example, when dataset1 establishes a new downstream relationship with dataset2."""
+    
+    RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.platform.event.v1.RelationshipChangeEvent")
+    def __init__(self,
+        sourceUrn: str,
+        destinationUrn: str,
+        operation: Union[str, "RelationshipChangeOperationClass"],
+        relationshipType: str,
+        auditStamp: "AuditStampClass",
+        auditHeader: Union[None, "KafkaAuditHeaderClass"]=None,
+        lifecycleOwner: Union[None, str]=None,
+        via: Union[None, str]=None,
+        properties: Union[None, Dict[str, str]]=None,
+    ):
+        super().__init__()
+        
+        self.auditHeader = auditHeader
+        self.sourceUrn = sourceUrn
+        self.destinationUrn = destinationUrn
+        self.operation = operation
+        self.relationshipType = relationshipType
+        self.lifecycleOwner = lifecycleOwner
+        self.via = via
+        self.properties = properties
+        self.auditStamp = auditStamp
+    
+    def _restore_defaults(self) -> None:
+        self.auditHeader = self.RECORD_SCHEMA.fields_dict["auditHeader"].default
+        self.sourceUrn = str()
+        self.destinationUrn = str()
+        self.operation = RelationshipChangeOperationClass.ADD
+        self.relationshipType = str()
+        self.lifecycleOwner = self.RECORD_SCHEMA.fields_dict["lifecycleOwner"].default
+        self.via = self.RECORD_SCHEMA.fields_dict["via"].default
+        self.properties = self.RECORD_SCHEMA.fields_dict["properties"].default
+        self.auditStamp = AuditStampClass._construct_with_defaults()
+    
+    
+    @property
+    def auditHeader(self) -> Union[None, "KafkaAuditHeaderClass"]:
+        """Kafka audit header containing metadata about the message itself.
+    Includes information like message ID, timestamp, and server details."""
+        return self._inner_dict.get('auditHeader')  # type: ignore
+    
+    @auditHeader.setter
+    def auditHeader(self, value: Union[None, "KafkaAuditHeaderClass"]) -> None:
+        self._inner_dict['auditHeader'] = value
+    
+    
+    @property
+    def sourceUrn(self) -> str:
+        """The URN (Uniform Resource Name) of the source entity in the relationship.
+    In a downstream relationship example, this would be the URN of the upstream dataset."""
+        return self._inner_dict.get('sourceUrn')  # type: ignore
+    
+    @sourceUrn.setter
+    def sourceUrn(self, value: str) -> None:
+        self._inner_dict['sourceUrn'] = value
+    
+    
+    @property
+    def destinationUrn(self) -> str:
+        """The URN of the destination entity in the relationship.
+    In a downstream relationship example, this would be the URN of the downstream dataset."""
+        return self._inner_dict.get('destinationUrn')  # type: ignore
+    
+    @destinationUrn.setter
+    def destinationUrn(self, value: str) -> None:
+        self._inner_dict['destinationUrn'] = value
+    
+    
+    @property
+    def operation(self) -> Union[str, "RelationshipChangeOperationClass"]:
+        """The operation being performed on this relationship.
+    Typically includes operations like ADD, REMOVE, or RESTATE."""
+        return self._inner_dict.get('operation')  # type: ignore
+    
+    @operation.setter
+    def operation(self, value: Union[str, "RelationshipChangeOperationClass"]) -> None:
+        self._inner_dict['operation'] = value
+    
+    
+    @property
+    def relationshipType(self) -> str:
+        """The type/category of relationship being established or modified.
+    Examples: "DownstreamOf", "Contains", "OwnedBy", "DerivedFrom", etc."""
+        return self._inner_dict.get('relationshipType')  # type: ignore
+    
+    @relationshipType.setter
+    def relationshipType(self, value: str) -> None:
+        self._inner_dict['relationshipType'] = value
+    
+    
+    @property
+    def lifecycleOwner(self) -> Union[None, str]:
+        """The system or service responsible for managing the lifecycle of this relationship.
+    This helps identify which component has authority over the relationship."""
+        return self._inner_dict.get('lifecycleOwner')  # type: ignore
+    
+    @lifecycleOwner.setter
+    def lifecycleOwner(self, value: Union[None, str]) -> None:
+        self._inner_dict['lifecycleOwner'] = value
+    
+    
+    @property
+    def via(self) -> Union[None, str]:
+        """Information about how or through what means this relationship was established.
+    Could indicate a specific pipeline, process, or tool that discovered/created the relationship."""
+        return self._inner_dict.get('via')  # type: ignore
+    
+    @via.setter
+    def via(self, value: Union[None, str]) -> None:
+        self._inner_dict['via'] = value
+    
+    
+    @property
+    def properties(self) -> Union[None, Dict[str, str]]:
+        """Additional custom properties associated with this relationship.
+    Allows for flexible extension without changing the schema."""
+        return self._inner_dict.get('properties')  # type: ignore
+    
+    @properties.setter
+    def properties(self, value: Union[None, Dict[str, str]]) -> None:
+        self._inner_dict['properties'] = value
+    
+    
+    @property
+    def auditStamp(self) -> "AuditStampClass":
+        """Stores information about who made this change and when.
+    Contains the actor (user or system) that performed the action and the timestamp."""
+        return self._inner_dict.get('auditStamp')  # type: ignore
+    
+    @auditStamp.setter
+    def auditStamp(self, value: "AuditStampClass") -> None:
+        self._inner_dict['auditStamp'] = value
+    
+    
+class RelationshipChangeOperationClass(object):
+    # No docs available.
+    
+    ADD = "ADD"
+    REMOVE = "REMOVE"
+    RESTATE = "RESTATE"
+    
+    
 class PlatformResourceInfoClass(_Aspect):
     """Platform Resource Info.
     These entities are for miscelaneous data that is used in non-core parts of the system.
@@ -37275,6 +37647,7 @@ class StructuredPropertyValueAssignmentClass(DictWrapper):
         values: List[Union[str, float]],
         created: Union[None, "AuditStampClass"]=None,
         lastModified: Union[None, "AuditStampClass"]=None,
+        attribution: Union[None, "MetadataAttributionClass"]=None,
     ):
         super().__init__()
         
@@ -37282,12 +37655,14 @@ class StructuredPropertyValueAssignmentClass(DictWrapper):
         self.values = values
         self.created = created
         self.lastModified = lastModified
+        self.attribution = attribution
     
     def _restore_defaults(self) -> None:
         self.propertyUrn = str()
         self.values = list()
         self.created = self.RECORD_SCHEMA.fields_dict["created"].default
         self.lastModified = self.RECORD_SCHEMA.fields_dict["lastModified"].default
+        self.attribution = self.RECORD_SCHEMA.fields_dict["attribution"].default
     
     
     @property
@@ -37330,6 +37705,16 @@ class StructuredPropertyValueAssignmentClass(DictWrapper):
         self._inner_dict['lastModified'] = value
     
     
+    @property
+    def attribution(self) -> Union[None, "MetadataAttributionClass"]:
+        """Information about who, why, and how this metadata was applied"""
+        return self._inner_dict.get('attribution')  # type: ignore
+    
+    @attribution.setter
+    def attribution(self, value: Union[None, "MetadataAttributionClass"]) -> None:
+        self._inner_dict['attribution'] = value
+    
+    
 class EntityChangeDetailsClass(DictWrapper):
     """Details involving an EntityChangeType. Used by Subscriptions to determine which
     change types should trigger a notification."""
@@ -39910,13 +40295,16 @@ __SCHEMA_TYPES = {
     'com.linkedin.pegasus2avro.identity.CorpUserEditableInfo': CorpUserEditableInfoClass,
     'com.linkedin.pegasus2avro.identity.CorpUserHomePageSettings': CorpUserHomePageSettingsClass,
     'com.linkedin.pegasus2avro.identity.CorpUserInfo': CorpUserInfoClass,
+    'com.linkedin.pegasus2avro.identity.CorpUserInvitationStatus': CorpUserInvitationStatusClass,
     'com.linkedin.pegasus2avro.identity.CorpUserSettings': CorpUserSettingsClass,
     'com.linkedin.pegasus2avro.identity.CorpUserStatus': CorpUserStatusClass,
     'com.linkedin.pegasus2avro.identity.CorpUserViewsSettings': CorpUserViewsSettingsClass,
     'com.linkedin.pegasus2avro.identity.GroupMembership': GroupMembershipClass,
+    'com.linkedin.pegasus2avro.identity.InvitationStatus': InvitationStatusClass,
     'com.linkedin.pegasus2avro.identity.InviteToken': InviteTokenClass,
     'com.linkedin.pegasus2avro.identity.NativeGroupMembership': NativeGroupMembershipClass,
     'com.linkedin.pegasus2avro.identity.RoleMembership': RoleMembershipClass,
+    'com.linkedin.pegasus2avro.identity.TokenType': TokenTypeClass,
     'com.linkedin.pegasus2avro.incident.IncidentActivityChange': IncidentActivityChangeClass,
     'com.linkedin.pegasus2avro.incident.IncidentActivityChangeType': IncidentActivityChangeTypeClass,
     'com.linkedin.pegasus2avro.incident.IncidentActivityEvent': IncidentActivityEventClass,
@@ -40031,6 +40419,7 @@ __SCHEMA_TYPES = {
     'com.linkedin.pegasus2avro.metadata.recommendation.RecommendationParams': RecommendationParamsClass,
     'com.linkedin.pegasus2avro.metadata.recommendation.RecommendationRenderType': RecommendationRenderTypeClass,
     'com.linkedin.pegasus2avro.metadata.recommendation.SearchParams': SearchParamsClass,
+    'com.linkedin.pegasus2avro.metadata.search.features.CorpUserUsageFeatures': CorpUserUsageFeaturesClass,
     'com.linkedin.pegasus2avro.metadata.search.features.CostCurrencyCode': CostCurrencyCodeClass,
     'com.linkedin.pegasus2avro.metadata.search.features.CostFeatures': CostFeaturesClass,
     'com.linkedin.pegasus2avro.metadata.search.features.LineageFeatures': LineageFeaturesClass,
@@ -40162,6 +40551,8 @@ __SCHEMA_TYPES = {
     'com.linkedin.pegasus2avro.persona.DataHubPersonaInfo': DataHubPersonaInfoClass,
     'com.linkedin.pegasus2avro.platform.event.v1.EntityChangeEvent': EntityChangeEventClass,
     'com.linkedin.pegasus2avro.platform.event.v1.Parameters': ParametersClass,
+    'com.linkedin.pegasus2avro.platform.event.v1.RelationshipChangeEvent': RelationshipChangeEventClass,
+    'com.linkedin.pegasus2avro.platform.event.v1.RelationshipChangeOperation': RelationshipChangeOperationClass,
     'com.linkedin.pegasus2avro.platformresource.PlatformResourceInfo': PlatformResourceInfoClass,
     'com.linkedin.pegasus2avro.platformresource.PlatformResourceKey': PlatformResourceKeyClass,
     'com.linkedin.pegasus2avro.policy.DataHubActorFilter': DataHubActorFilterClass,
@@ -40670,13 +41061,16 @@ __SCHEMA_TYPES = {
     'CorpUserEditableInfo': CorpUserEditableInfoClass,
     'CorpUserHomePageSettings': CorpUserHomePageSettingsClass,
     'CorpUserInfo': CorpUserInfoClass,
+    'CorpUserInvitationStatus': CorpUserInvitationStatusClass,
     'CorpUserSettings': CorpUserSettingsClass,
     'CorpUserStatus': CorpUserStatusClass,
     'CorpUserViewsSettings': CorpUserViewsSettingsClass,
     'GroupMembership': GroupMembershipClass,
+    'InvitationStatus': InvitationStatusClass,
     'InviteToken': InviteTokenClass,
     'NativeGroupMembership': NativeGroupMembershipClass,
     'RoleMembership': RoleMembershipClass,
+    'TokenType': TokenTypeClass,
     'IncidentActivityChange': IncidentActivityChangeClass,
     'IncidentActivityChangeType': IncidentActivityChangeTypeClass,
     'IncidentActivityEvent': IncidentActivityEventClass,
@@ -40791,6 +41185,7 @@ __SCHEMA_TYPES = {
     'RecommendationParams': RecommendationParamsClass,
     'RecommendationRenderType': RecommendationRenderTypeClass,
     'SearchParams': SearchParamsClass,
+    'CorpUserUsageFeatures': CorpUserUsageFeaturesClass,
     'CostCurrencyCode': CostCurrencyCodeClass,
     'CostFeatures': CostFeaturesClass,
     'LineageFeatures': LineageFeaturesClass,
@@ -40922,6 +41317,8 @@ __SCHEMA_TYPES = {
     'DataHubPersonaInfo': DataHubPersonaInfoClass,
     'EntityChangeEvent': EntityChangeEventClass,
     'Parameters': ParametersClass,
+    'RelationshipChangeEvent': RelationshipChangeEventClass,
+    'RelationshipChangeOperation': RelationshipChangeOperationClass,
     'PlatformResourceInfo': PlatformResourceInfoClass,
     'PlatformResourceKey': PlatformResourceKeyClass,
     'DataHubActorFilter': DataHubActorFilterClass,
@@ -41139,6 +41536,7 @@ ASPECT_CLASSES: List[Type[_Aspect]] = [
     GroupMembershipClass,
     CorpGroupInfoClass,
     InviteTokenClass,
+    CorpUserInvitationStatusClass,
     CorpUserInfoClass,
     CorpUserCredentialsClass,
     CorpGroupSettingsClass,
@@ -41172,6 +41570,7 @@ ASPECT_CLASSES: List[Type[_Aspect]] = [
     PostInfoClass,
     CostFeaturesClass,
     LineageFeaturesClass,
+    CorpUserUsageFeaturesClass,
     UsageFeaturesClass,
     StorageFeaturesClass,
     RecommendationModuleClass,
@@ -41433,6 +41832,7 @@ class AspectBag(TypedDict, total=False):
     groupMembership: GroupMembershipClass
     corpGroupInfo: CorpGroupInfoClass
     inviteToken: InviteTokenClass
+    corpUserInvitationStatus: CorpUserInvitationStatusClass
     corpUserInfo: CorpUserInfoClass
     corpUserCredentials: CorpUserCredentialsClass
     corpGroupSettings: CorpGroupSettingsClass
@@ -41466,6 +41866,7 @@ class AspectBag(TypedDict, total=False):
     postInfo: PostInfoClass
     costFeatures: CostFeaturesClass
     lineageFeatures: LineageFeaturesClass
+    corpUserUsageFeatures: CorpUserUsageFeaturesClass
     usageFeatures: UsageFeaturesClass
     storageFeatures: StorageFeaturesClass
     recommendationModule: RecommendationModuleClass