acryl-datahub-cloud 0.3.6.9rc2__py3-none-any.whl → 0.3.7__py3-none-any.whl

acryl_datahub_cloud/metadata/_urns/urn_defs.py

@@ -21,6 +21,51 @@ from datahub.utilities.urns.error import InvalidUrnError
 
 deprecated = functools.partial(_sphinx_deprecated, version="0.12.0.2")
 
+if TYPE_CHECKING:
+    from datahub.metadata.schema_classes import DataHubConnectionKeyClass
+
+class DataHubConnectionUrn(_SpecificUrn):
+    ENTITY_TYPE: ClassVar[str] = "dataHubConnection"
+    URN_PARTS: ClassVar[int] = 1
+
+    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+        if _allow_coercion:
+            # Field coercion logic (if any is required).
+            id = UrnEncoder.encode_string(id)
+
+        # Validation logic.
+        if not id:
+            raise InvalidUrnError("DataHubConnectionUrn id cannot be empty")
+        if UrnEncoder.contains_reserved_char(id):
+            raise InvalidUrnError(f'DataHubConnectionUrn id contains reserved characters')
+
+        super().__init__(self.ENTITY_TYPE, [id])
+
+    @classmethod
+    def _parse_ids(cls, entity_ids: List[str]) -> "DataHubConnectionUrn":
+        if len(entity_ids) != cls.URN_PARTS:
+            raise InvalidUrnError(f"DataHubConnectionUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        return cls(id=entity_ids[0], _allow_coercion=False)
+
+    @classmethod
+    def underlying_key_aspect_type(cls) -> Type["DataHubConnectionKeyClass"]:
+        from datahub.metadata.schema_classes import DataHubConnectionKeyClass
+
+        return DataHubConnectionKeyClass
+
+    def to_key_aspect(self) -> "DataHubConnectionKeyClass":
+        from datahub.metadata.schema_classes import DataHubConnectionKeyClass
+
+        return DataHubConnectionKeyClass(id=self.id)
+
+    @classmethod
+    def from_key_aspect(cls, key_aspect: "DataHubConnectionKeyClass") -> "DataHubConnectionUrn":
+        return cls(id=key_aspect.id)
+
+    @property
+    def id(self) -> str:
+        return self.entity_ids[0]
+
 if TYPE_CHECKING:
     from datahub.metadata.schema_classes import DataHubRoleKeyClass
 
@@ -66,6 +111,96 @@ class DataHubRoleUrn(_SpecificUrn):
     def id(self) -> str:
         return self.entity_ids[0]
 
+if TYPE_CHECKING:
+    from datahub.metadata.schema_classes import ActionRequestKeyClass
+
+class ActionRequestUrn(_SpecificUrn):
+    ENTITY_TYPE: ClassVar[str] = "actionRequest"
+    URN_PARTS: ClassVar[int] = 1
+
+    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+        if _allow_coercion:
+            # Field coercion logic (if any is required).
+            id = UrnEncoder.encode_string(id)
+
+        # Validation logic.
+        if not id:
+            raise InvalidUrnError("ActionRequestUrn id cannot be empty")
+        if UrnEncoder.contains_reserved_char(id):
+            raise InvalidUrnError(f'ActionRequestUrn id contains reserved characters')
+
+        super().__init__(self.ENTITY_TYPE, [id])
+
+    @classmethod
+    def _parse_ids(cls, entity_ids: List[str]) -> "ActionRequestUrn":
+        if len(entity_ids) != cls.URN_PARTS:
+            raise InvalidUrnError(f"ActionRequestUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        return cls(id=entity_ids[0], _allow_coercion=False)
+
+    @classmethod
+    def underlying_key_aspect_type(cls) -> Type["ActionRequestKeyClass"]:
+        from datahub.metadata.schema_classes import ActionRequestKeyClass
+
+        return ActionRequestKeyClass
+
+    def to_key_aspect(self) -> "ActionRequestKeyClass":
+        from datahub.metadata.schema_classes import ActionRequestKeyClass
+
+        return ActionRequestKeyClass(id=self.id)
+
+    @classmethod
+    def from_key_aspect(cls, key_aspect: "ActionRequestKeyClass") -> "ActionRequestUrn":
+        return cls(id=key_aspect.id)
+
+    @property
+    def id(self) -> str:
+        return self.entity_ids[0]
+
+if TYPE_CHECKING:
+    from datahub.metadata.schema_classes import DataHubIngestionSourceKeyClass
+
+class DataHubIngestionSourceUrn(_SpecificUrn):
+    ENTITY_TYPE: ClassVar[str] = "dataHubIngestionSource"
+    URN_PARTS: ClassVar[int] = 1
+
+    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+        if _allow_coercion:
+            # Field coercion logic (if any is required).
+            id = UrnEncoder.encode_string(id)
+
+        # Validation logic.
+        if not id:
+            raise InvalidUrnError("DataHubIngestionSourceUrn id cannot be empty")
+        if UrnEncoder.contains_reserved_char(id):
+            raise InvalidUrnError(f'DataHubIngestionSourceUrn id contains reserved characters')
+
+        super().__init__(self.ENTITY_TYPE, [id])
+
+    @classmethod
+    def _parse_ids(cls, entity_ids: List[str]) -> "DataHubIngestionSourceUrn":
+        if len(entity_ids) != cls.URN_PARTS:
+            raise InvalidUrnError(f"DataHubIngestionSourceUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        return cls(id=entity_ids[0], _allow_coercion=False)
+
+    @classmethod
+    def underlying_key_aspect_type(cls) -> Type["DataHubIngestionSourceKeyClass"]:
+        from datahub.metadata.schema_classes import DataHubIngestionSourceKeyClass
+
+        return DataHubIngestionSourceKeyClass
+
+    def to_key_aspect(self) -> "DataHubIngestionSourceKeyClass":
+        from datahub.metadata.schema_classes import DataHubIngestionSourceKeyClass
+
+        return DataHubIngestionSourceKeyClass(id=self.id)
+
+    @classmethod
+    def from_key_aspect(cls, key_aspect: "DataHubIngestionSourceKeyClass") -> "DataHubIngestionSourceUrn":
+        return cls(id=key_aspect.id)
+
+    @property
+    def id(self) -> str:
+        return self.entity_ids[0]
+
 if TYPE_CHECKING:
     from datahub.metadata.schema_classes import FormKeyClass
 
@@ -218,6 +353,60 @@ class GlossaryNodeUrn(_SpecificUrn):
     def name(self) -> str:
         return self.entity_ids[0]
 
+if TYPE_CHECKING:
+    from datahub.metadata.schema_classes import DataPlatformInstanceKeyClass
+
+class DataPlatformInstanceUrn(_SpecificUrn):
+    ENTITY_TYPE: ClassVar[str] = "dataPlatformInstance"
+    URN_PARTS: ClassVar[int] = 2
+
+    def __init__(self, platform: str, instance: str, *, _allow_coercion: bool = True) -> None:
+        if _allow_coercion:
+            # Field coercion logic (if any is required).
+            platform = DataPlatformUrn(platform).urn()
+            instance = UrnEncoder.encode_string(instance)
+
+        # Validation logic.
+        if not platform:
+            raise InvalidUrnError("DataPlatformInstanceUrn platform cannot be empty")
+        platform = str(platform)
+        assert DataPlatformUrn.from_string(platform)
+        if not instance:
+            raise InvalidUrnError("DataPlatformInstanceUrn instance cannot be empty")
+        if UrnEncoder.contains_reserved_char(instance):
+            raise InvalidUrnError(f'DataPlatformInstanceUrn instance contains reserved characters')
+
+        super().__init__(self.ENTITY_TYPE, [platform, instance])
+
+    @classmethod
+    def _parse_ids(cls, entity_ids: List[str]) -> "DataPlatformInstanceUrn":
+        if len(entity_ids) != cls.URN_PARTS:
+            raise InvalidUrnError(f"DataPlatformInstanceUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        return cls(platform=entity_ids[0], instance=entity_ids[1], _allow_coercion=False)
+
+    @classmethod
+    def underlying_key_aspect_type(cls) -> Type["DataPlatformInstanceKeyClass"]:
+        from datahub.metadata.schema_classes import DataPlatformInstanceKeyClass
+
+        return DataPlatformInstanceKeyClass
+
+    def to_key_aspect(self) -> "DataPlatformInstanceKeyClass":
+        from datahub.metadata.schema_classes import DataPlatformInstanceKeyClass
+
+        return DataPlatformInstanceKeyClass(platform=self.platform, instance=self.instance)
+
+    @classmethod
+    def from_key_aspect(cls, key_aspect: "DataPlatformInstanceKeyClass") -> "DataPlatformInstanceUrn":
+        return cls(platform=key_aspect.platform, instance=key_aspect.instance)
+
+    @property
+    def platform(self) -> str:
+        return self.entity_ids[0]
+
+    @property
+    def instance(self) -> str:
+        return self.entity_ids[1]
+
 if TYPE_CHECKING:
     from datahub.metadata.schema_classes import RoleKeyClass
 
@@ -497,6 +686,105 @@ class ContainerUrn(_SpecificUrn):
     def guid(self) -> str:
         return self.entity_ids[0]
 
+if TYPE_CHECKING:
+    from datahub.metadata.schema_classes import DataHubRetentionKeyClass
+
+class DataHubRetentionUrn(_SpecificUrn):
+    ENTITY_TYPE: ClassVar[str] = "dataHubRetention"
+    URN_PARTS: ClassVar[int] = 2
+
+    def __init__(self, entity_name: str, aspect_name: str, *, _allow_coercion: bool = True) -> None:
+        if _allow_coercion:
+            # Field coercion logic (if any is required).
+            entity_name = UrnEncoder.encode_string(entity_name)
+            aspect_name = UrnEncoder.encode_string(aspect_name)
+
+        # Validation logic.
+        if not entity_name:
+            raise InvalidUrnError("DataHubRetentionUrn entity_name cannot be empty")
+        if UrnEncoder.contains_reserved_char(entity_name):
+            raise InvalidUrnError(f'DataHubRetentionUrn entity_name contains reserved characters')
+        if not aspect_name:
+            raise InvalidUrnError("DataHubRetentionUrn aspect_name cannot be empty")
+        if UrnEncoder.contains_reserved_char(aspect_name):
+            raise InvalidUrnError(f'DataHubRetentionUrn aspect_name contains reserved characters')
+
+        super().__init__(self.ENTITY_TYPE, [entity_name, aspect_name])
+
+    @classmethod
+    def _parse_ids(cls, entity_ids: List[str]) -> "DataHubRetentionUrn":
+        if len(entity_ids) != cls.URN_PARTS:
+            raise InvalidUrnError(f"DataHubRetentionUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        return cls(entity_name=entity_ids[0], aspect_name=entity_ids[1], _allow_coercion=False)
+
+    @classmethod
+    def underlying_key_aspect_type(cls) -> Type["DataHubRetentionKeyClass"]:
+        from datahub.metadata.schema_classes import DataHubRetentionKeyClass
+
+        return DataHubRetentionKeyClass
+
+    def to_key_aspect(self) -> "DataHubRetentionKeyClass":
+        from datahub.metadata.schema_classes import DataHubRetentionKeyClass
+
+        return DataHubRetentionKeyClass(entityName=self.entity_name, aspectName=self.aspect_name)
+
+    @classmethod
+    def from_key_aspect(cls, key_aspect: "DataHubRetentionKeyClass") -> "DataHubRetentionUrn":
+        return cls(entity_name=key_aspect.entityName, aspect_name=key_aspect.aspectName)
+
+    @property
+    def entity_name(self) -> str:
+        return self.entity_ids[0]
+
+    @property
+    def aspect_name(self) -> str:
+        return self.entity_ids[1]
+
+if TYPE_CHECKING:
+    from datahub.metadata.schema_classes import LinkPreviewKeyClass
+
+class LinkPreviewUrn(_SpecificUrn):
+    ENTITY_TYPE: ClassVar[str] = "linkPreview"
+    URN_PARTS: ClassVar[int] = 1
+
+    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+        if _allow_coercion:
+            # Field coercion logic (if any is required).
+            id = UrnEncoder.encode_string(id)
+
+        # Validation logic.
+        if not id:
+            raise InvalidUrnError("LinkPreviewUrn id cannot be empty")
+        if UrnEncoder.contains_reserved_char(id):
+            raise InvalidUrnError(f'LinkPreviewUrn id contains reserved characters')
+
+        super().__init__(self.ENTITY_TYPE, [id])
+
+    @classmethod
+    def _parse_ids(cls, entity_ids: List[str]) -> "LinkPreviewUrn":
+        if len(entity_ids) != cls.URN_PARTS:
+            raise InvalidUrnError(f"LinkPreviewUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        return cls(id=entity_ids[0], _allow_coercion=False)
+
+    @classmethod
+    def underlying_key_aspect_type(cls) -> Type["LinkPreviewKeyClass"]:
+        from datahub.metadata.schema_classes import LinkPreviewKeyClass
+
+        return LinkPreviewKeyClass
+
+    def to_key_aspect(self) -> "LinkPreviewKeyClass":
+        from datahub.metadata.schema_classes import LinkPreviewKeyClass
+
+        return LinkPreviewKeyClass(id=self.id)
+
+    @classmethod
+    def from_key_aspect(cls, key_aspect: "LinkPreviewKeyClass") -> "LinkPreviewUrn":
+        return cls(id=key_aspect.id)
+
+    @property
+    def id(self) -> str:
+        return self.entity_ids[0]
+
 if TYPE_CHECKING:
     from datahub.metadata.schema_classes import PostKeyClass
 
@@ -542,6 +830,96 @@ class PostUrn(_SpecificUrn):
     def id(self) -> str:
         return self.entity_ids[0]
 
+if TYPE_CHECKING:
+    from datahub.metadata.schema_classes import DataHubSecretKeyClass
+
+class DataHubSecretUrn(_SpecificUrn):
+    ENTITY_TYPE: ClassVar[str] = "dataHubSecret"
+    URN_PARTS: ClassVar[int] = 1
+
+    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+        if _allow_coercion:
+            # Field coercion logic (if any is required).
+            id = UrnEncoder.encode_string(id)
+
+        # Validation logic.
+        if not id:
+            raise InvalidUrnError("DataHubSecretUrn id cannot be empty")
+        if UrnEncoder.contains_reserved_char(id):
+            raise InvalidUrnError(f'DataHubSecretUrn id contains reserved characters')
+
+        super().__init__(self.ENTITY_TYPE, [id])
+
+    @classmethod
+    def _parse_ids(cls, entity_ids: List[str]) -> "DataHubSecretUrn":
+        if len(entity_ids) != cls.URN_PARTS:
+            raise InvalidUrnError(f"DataHubSecretUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        return cls(id=entity_ids[0], _allow_coercion=False)
+
+    @classmethod
+    def underlying_key_aspect_type(cls) -> Type["DataHubSecretKeyClass"]:
+        from datahub.metadata.schema_classes import DataHubSecretKeyClass
+
+        return DataHubSecretKeyClass
+
+    def to_key_aspect(self) -> "DataHubSecretKeyClass":
+        from datahub.metadata.schema_classes import DataHubSecretKeyClass
+
+        return DataHubSecretKeyClass(id=self.id)
+
+    @classmethod
+    def from_key_aspect(cls, key_aspect: "DataHubSecretKeyClass") -> "DataHubSecretUrn":
+        return cls(id=key_aspect.id)
+
+    @property
+    def id(self) -> str:
+        return self.entity_ids[0]
+
+if TYPE_CHECKING:
+    from datahub.metadata.schema_classes import DataHubStepStateKeyClass
+
+class DataHubStepStateUrn(_SpecificUrn):
+    ENTITY_TYPE: ClassVar[str] = "dataHubStepState"
+    URN_PARTS: ClassVar[int] = 1
+
+    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+        if _allow_coercion:
+            # Field coercion logic (if any is required).
+            id = UrnEncoder.encode_string(id)
+
+        # Validation logic.
+        if not id:
+            raise InvalidUrnError("DataHubStepStateUrn id cannot be empty")
+        if UrnEncoder.contains_reserved_char(id):
+            raise InvalidUrnError(f'DataHubStepStateUrn id contains reserved characters')
+
+        super().__init__(self.ENTITY_TYPE, [id])
+
+    @classmethod
+    def _parse_ids(cls, entity_ids: List[str]) -> "DataHubStepStateUrn":
+        if len(entity_ids) != cls.URN_PARTS:
+            raise InvalidUrnError(f"DataHubStepStateUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        return cls(id=entity_ids[0], _allow_coercion=False)
+
+    @classmethod
+    def underlying_key_aspect_type(cls) -> Type["DataHubStepStateKeyClass"]:
+        from datahub.metadata.schema_classes import DataHubStepStateKeyClass
+
+        return DataHubStepStateKeyClass
+
+    def to_key_aspect(self) -> "DataHubStepStateKeyClass":
+        from datahub.metadata.schema_classes import DataHubStepStateKeyClass
+
+        return DataHubStepStateKeyClass(id=self.id)
+
+    @classmethod
+    def from_key_aspect(cls, key_aspect: "DataHubStepStateKeyClass") -> "DataHubStepStateUrn":
+        return cls(id=key_aspect.id)
+
+    @property
+    def id(self) -> str:
+        return self.entity_ids[0]
+
 if TYPE_CHECKING:
     from datahub.metadata.schema_classes import OwnershipTypeKeyClass
 
@@ -689,13 +1067,58 @@ class DataJobUrn(_SpecificUrn):
         return self.job_id
 
     @property
-    def flow(self) -> str:
+    def flow(self) -> str:
+        return self.entity_ids[0]
+
+    @property
+    def job_id(self) -> str:
+        return self.entity_ids[1]
+
+if TYPE_CHECKING:
+    from datahub.metadata.schema_classes import ExecutionRequestKeyClass
+
+class DataHubExecutionRequestUrn(_SpecificUrn):
+    ENTITY_TYPE: ClassVar[str] = "dataHubExecutionRequest"
+    URN_PARTS: ClassVar[int] = 1
+
+    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+        if _allow_coercion:
+            # Field coercion logic (if any is required).
+            id = UrnEncoder.encode_string(id)
+
+        # Validation logic.
+        if not id:
+            raise InvalidUrnError("DataHubExecutionRequestUrn id cannot be empty")
+        if UrnEncoder.contains_reserved_char(id):
+            raise InvalidUrnError(f'DataHubExecutionRequestUrn id contains reserved characters')
+
+        super().__init__(self.ENTITY_TYPE, [id])
+
+    @classmethod
+    def _parse_ids(cls, entity_ids: List[str]) -> "DataHubExecutionRequestUrn":
+        if len(entity_ids) != cls.URN_PARTS:
+            raise InvalidUrnError(f"DataHubExecutionRequestUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        return cls(id=entity_ids[0], _allow_coercion=False)
+
+    @classmethod
+    def underlying_key_aspect_type(cls) -> Type["ExecutionRequestKeyClass"]:
+        from datahub.metadata.schema_classes import ExecutionRequestKeyClass
+
+        return ExecutionRequestKeyClass
+
+    def to_key_aspect(self) -> "ExecutionRequestKeyClass":
+        from datahub.metadata.schema_classes import ExecutionRequestKeyClass
+
+        return ExecutionRequestKeyClass(id=self.id)
+
+    @classmethod
+    def from_key_aspect(cls, key_aspect: "ExecutionRequestKeyClass") -> "DataHubExecutionRequestUrn":
+        return cls(id=key_aspect.id)
+
+    @property
+    def id(self) -> str:
         return self.entity_ids[0]
 
-    @property
-    def job_id(self) -> str:
-        return self.entity_ids[1]
-
 if TYPE_CHECKING:
     from datahub.metadata.schema_classes import SubscriptionKeyClass
 
@@ -1116,6 +1539,96 @@ class CorpGroupUrn(_SpecificUrn):
     def name(self) -> str:
         return self.entity_ids[0]
 
+if TYPE_CHECKING:
+    from datahub.metadata.schema_classes import DataHubUpgradeKeyClass
+
+class DataHubUpgradeUrn(_SpecificUrn):
+    ENTITY_TYPE: ClassVar[str] = "dataHubUpgrade"
+    URN_PARTS: ClassVar[int] = 1
+
+    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+        if _allow_coercion:
+            # Field coercion logic (if any is required).
+            id = UrnEncoder.encode_string(id)
+
+        # Validation logic.
+        if not id:
+            raise InvalidUrnError("DataHubUpgradeUrn id cannot be empty")
+        if UrnEncoder.contains_reserved_char(id):
+            raise InvalidUrnError(f'DataHubUpgradeUrn id contains reserved characters')
+
+        super().__init__(self.ENTITY_TYPE, [id])
+
+    @classmethod
+    def _parse_ids(cls, entity_ids: List[str]) -> "DataHubUpgradeUrn":
+        if len(entity_ids) != cls.URN_PARTS:
+            raise InvalidUrnError(f"DataHubUpgradeUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        return cls(id=entity_ids[0], _allow_coercion=False)
+
+    @classmethod
+    def underlying_key_aspect_type(cls) -> Type["DataHubUpgradeKeyClass"]:
+        from datahub.metadata.schema_classes import DataHubUpgradeKeyClass
+
+        return DataHubUpgradeKeyClass
+
+    def to_key_aspect(self) -> "DataHubUpgradeKeyClass":
+        from datahub.metadata.schema_classes import DataHubUpgradeKeyClass
+
+        return DataHubUpgradeKeyClass(id=self.id)
+
+    @classmethod
+    def from_key_aspect(cls, key_aspect: "DataHubUpgradeKeyClass") -> "DataHubUpgradeUrn":
+        return cls(id=key_aspect.id)
+
+    @property
+    def id(self) -> str:
+        return self.entity_ids[0]
+
+if TYPE_CHECKING:
+    from datahub.metadata.schema_classes import GlobalSettingsKeyClass
+
+class GlobalSettingsUrn(_SpecificUrn):
+    ENTITY_TYPE: ClassVar[str] = "globalSettings"
+    URN_PARTS: ClassVar[int] = 1
+
+    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+        if _allow_coercion:
+            # Field coercion logic (if any is required).
+            id = UrnEncoder.encode_string(id)
+
+        # Validation logic.
+        if not id:
+            raise InvalidUrnError("GlobalSettingsUrn id cannot be empty")
+        if UrnEncoder.contains_reserved_char(id):
+            raise InvalidUrnError(f'GlobalSettingsUrn id contains reserved characters')
+
+        super().__init__(self.ENTITY_TYPE, [id])
+
+    @classmethod
+    def _parse_ids(cls, entity_ids: List[str]) -> "GlobalSettingsUrn":
+        if len(entity_ids) != cls.URN_PARTS:
+            raise InvalidUrnError(f"GlobalSettingsUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        return cls(id=entity_ids[0], _allow_coercion=False)
+
+    @classmethod
+    def underlying_key_aspect_type(cls) -> Type["GlobalSettingsKeyClass"]:
+        from datahub.metadata.schema_classes import GlobalSettingsKeyClass
+
+        return GlobalSettingsKeyClass
+
+    def to_key_aspect(self) -> "GlobalSettingsKeyClass":
+        from datahub.metadata.schema_classes import GlobalSettingsKeyClass
+
+        return GlobalSettingsKeyClass(id=self.id)
+
+    @classmethod
+    def from_key_aspect(cls, key_aspect: "GlobalSettingsKeyClass") -> "GlobalSettingsUrn":
+        return cls(id=key_aspect.id)
+
+    @property
+    def id(self) -> str:
+        return self.entity_ids[0]
+
 if TYPE_CHECKING:
     from datahub.metadata.schema_classes import MLFeatureTableKeyClass
 
@@ -1170,6 +1683,51 @@ class MlFeatureTableUrn(_SpecificUrn):
     def name(self) -> str:
         return self.entity_ids[1]
 
+if TYPE_CHECKING:
+    from datahub.metadata.schema_classes import DataHubPersonaKeyClass
+
+class DataHubPersonaUrn(_SpecificUrn):
+    ENTITY_TYPE: ClassVar[str] = "dataHubPersona"
+    URN_PARTS: ClassVar[int] = 1
+
+    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+        if _allow_coercion:
+            # Field coercion logic (if any is required).
+            id = UrnEncoder.encode_string(id)
+
+        # Validation logic.
+        if not id:
+            raise InvalidUrnError("DataHubPersonaUrn id cannot be empty")
+        if UrnEncoder.contains_reserved_char(id):
+            raise InvalidUrnError(f'DataHubPersonaUrn id contains reserved characters')
+
+        super().__init__(self.ENTITY_TYPE, [id])
+
+    @classmethod
+    def _parse_ids(cls, entity_ids: List[str]) -> "DataHubPersonaUrn":
+        if len(entity_ids) != cls.URN_PARTS:
+            raise InvalidUrnError(f"DataHubPersonaUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        return cls(id=entity_ids[0], _allow_coercion=False)
+
+    @classmethod
+    def underlying_key_aspect_type(cls) -> Type["DataHubPersonaKeyClass"]:
+        from datahub.metadata.schema_classes import DataHubPersonaKeyClass
+
+        return DataHubPersonaKeyClass
+
+    def to_key_aspect(self) -> "DataHubPersonaKeyClass":
+        from datahub.metadata.schema_classes import DataHubPersonaKeyClass
+
+        return DataHubPersonaKeyClass(id=self.id)
+
+    @classmethod
+    def from_key_aspect(cls, key_aspect: "DataHubPersonaKeyClass") -> "DataHubPersonaUrn":
+        return cls(id=key_aspect.id)
+
+    @property
+    def id(self) -> str:
+        return self.entity_ids[0]
+
 if TYPE_CHECKING:
     from datahub.metadata.schema_classes import TagKeyClass
 
@@ -1675,6 +2233,51 @@ class MlPrimaryKeyUrn(_SpecificUrn):
     def name(self) -> str:
         return self.entity_ids[1]
 
+if TYPE_CHECKING:
+    from datahub.metadata.schema_classes import DataHubAccessTokenKeyClass
+
+class DataHubAccessTokenUrn(_SpecificUrn):
+    ENTITY_TYPE: ClassVar[str] = "dataHubAccessToken"
+    URN_PARTS: ClassVar[int] = 1
+
+    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+        if _allow_coercion:
+            # Field coercion logic (if any is required).
+            id = UrnEncoder.encode_string(id)
+
+        # Validation logic.
+        if not id:
+            raise InvalidUrnError("DataHubAccessTokenUrn id cannot be empty")
+        if UrnEncoder.contains_reserved_char(id):
+            raise InvalidUrnError(f'DataHubAccessTokenUrn id contains reserved characters')
+
+        super().__init__(self.ENTITY_TYPE, [id])
+
+    @classmethod
+    def _parse_ids(cls, entity_ids: List[str]) -> "DataHubAccessTokenUrn":
+        if len(entity_ids) != cls.URN_PARTS:
+            raise InvalidUrnError(f"DataHubAccessTokenUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        return cls(id=entity_ids[0], _allow_coercion=False)
+
+    @classmethod
+    def underlying_key_aspect_type(cls) -> Type["DataHubAccessTokenKeyClass"]:
+        from datahub.metadata.schema_classes import DataHubAccessTokenKeyClass
+
+        return DataHubAccessTokenKeyClass
+
+    def to_key_aspect(self) -> "DataHubAccessTokenKeyClass":
+        from datahub.metadata.schema_classes import DataHubAccessTokenKeyClass
+
+        return DataHubAccessTokenKeyClass(id=self.id)
+
+    @classmethod
+    def from_key_aspect(cls, key_aspect: "DataHubAccessTokenKeyClass") -> "DataHubAccessTokenUrn":
+        return cls(id=key_aspect.id)
+
+    @property
+    def id(self) -> str:
+        return self.entity_ids[0]
+
 if TYPE_CHECKING:
     from datahub.metadata.schema_classes import DataPlatformKeyClass
 
@@ -2017,6 +2620,96 @@ class MonitorUrn(_SpecificUrn):
     def id(self) -> str:
         return self.entity_ids[1]
 
+if TYPE_CHECKING:
+    from datahub.metadata.schema_classes import InviteTokenKeyClass
+
+class InviteTokenUrn(_SpecificUrn):
+    ENTITY_TYPE: ClassVar[str] = "inviteToken"
+    URN_PARTS: ClassVar[int] = 1
+
+    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+        if _allow_coercion:
+            # Field coercion logic (if any is required).
+            id = UrnEncoder.encode_string(id)
+
+        # Validation logic.
+        if not id:
+            raise InvalidUrnError("InviteTokenUrn id cannot be empty")
+        if UrnEncoder.contains_reserved_char(id):
+            raise InvalidUrnError(f'InviteTokenUrn id contains reserved characters')
+
+        super().__init__(self.ENTITY_TYPE, [id])
+
+    @classmethod
+    def _parse_ids(cls, entity_ids: List[str]) -> "InviteTokenUrn":
+        if len(entity_ids) != cls.URN_PARTS:
+            raise InvalidUrnError(f"InviteTokenUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        return cls(id=entity_ids[0], _allow_coercion=False)
+
+    @classmethod
+    def underlying_key_aspect_type(cls) -> Type["InviteTokenKeyClass"]:
+        from datahub.metadata.schema_classes import InviteTokenKeyClass
+
+        return InviteTokenKeyClass
+
+    def to_key_aspect(self) -> "InviteTokenKeyClass":
+        from datahub.metadata.schema_classes import InviteTokenKeyClass
+
+        return InviteTokenKeyClass(id=self.id)
+
+    @classmethod
+    def from_key_aspect(cls, key_aspect: "InviteTokenKeyClass") -> "InviteTokenUrn":
+        return cls(id=key_aspect.id)
+
+    @property
+    def id(self) -> str:
+        return self.entity_ids[0]
+
+if TYPE_CHECKING:
+    from datahub.metadata.schema_classes import DataHubPolicyKeyClass
+
+class DataHubPolicyUrn(_SpecificUrn):
+    ENTITY_TYPE: ClassVar[str] = "dataHubPolicy"
+    URN_PARTS: ClassVar[int] = 1
+
+    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+        if _allow_coercion:
+            # Field coercion logic (if any is required).
+            id = UrnEncoder.encode_string(id)
+
+        # Validation logic.
+        if not id:
+            raise InvalidUrnError("DataHubPolicyUrn id cannot be empty")
+        if UrnEncoder.contains_reserved_char(id):
+            raise InvalidUrnError(f'DataHubPolicyUrn id contains reserved characters')
+
+        super().__init__(self.ENTITY_TYPE, [id])
+
+    @classmethod
+    def _parse_ids(cls, entity_ids: List[str]) -> "DataHubPolicyUrn":
+        if len(entity_ids) != cls.URN_PARTS:
+            raise InvalidUrnError(f"DataHubPolicyUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        return cls(id=entity_ids[0], _allow_coercion=False)
+
+    @classmethod
+    def underlying_key_aspect_type(cls) -> Type["DataHubPolicyKeyClass"]:
+        from datahub.metadata.schema_classes import DataHubPolicyKeyClass
+
+        return DataHubPolicyKeyClass
+
+    def to_key_aspect(self) -> "DataHubPolicyKeyClass":
+        from datahub.metadata.schema_classes import DataHubPolicyKeyClass
+
+        return DataHubPolicyKeyClass(id=self.id)
+
+    @classmethod
+    def from_key_aspect(cls, key_aspect: "DataHubPolicyKeyClass") -> "DataHubPolicyUrn":
+        return cls(id=key_aspect.id)
+
+    @property
+    def id(self) -> str:
+        return self.entity_ids[0]
+
 if TYPE_CHECKING:
     from datahub.metadata.schema_classes import DomainKeyClass
 
@@ -2067,6 +2760,96 @@ class DomainUrn(_SpecificUrn):
     def id(self) -> str:
         return self.entity_ids[0]
 
+if TYPE_CHECKING:
+    from datahub.metadata.schema_classes import DataHubActionKeyClass
+
+class DataHubActionUrn(_SpecificUrn):
+    ENTITY_TYPE: ClassVar[str] = "dataHubAction"
+    URN_PARTS: ClassVar[int] = 1
+
+    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+        if _allow_coercion:
+            # Field coercion logic (if any is required).
+            id = UrnEncoder.encode_string(id)
+
+        # Validation logic.
+        if not id:
+            raise InvalidUrnError("DataHubActionUrn id cannot be empty")
+        if UrnEncoder.contains_reserved_char(id):
+            raise InvalidUrnError(f'DataHubActionUrn id contains reserved characters')
+
+        super().__init__(self.ENTITY_TYPE, [id])
+
+    @classmethod
+    def _parse_ids(cls, entity_ids: List[str]) -> "DataHubActionUrn":
+        if len(entity_ids) != cls.URN_PARTS:
+            raise InvalidUrnError(f"DataHubActionUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        return cls(id=entity_ids[0], _allow_coercion=False)
+
+    @classmethod
+    def underlying_key_aspect_type(cls) -> Type["DataHubActionKeyClass"]:
+        from datahub.metadata.schema_classes import DataHubActionKeyClass
+
+        return DataHubActionKeyClass
+
+    def to_key_aspect(self) -> "DataHubActionKeyClass":
+        from datahub.metadata.schema_classes import DataHubActionKeyClass
+
+        return DataHubActionKeyClass(id=self.id)
+
+    @classmethod
+    def from_key_aspect(cls, key_aspect: "DataHubActionKeyClass") -> "DataHubActionUrn":
+        return cls(id=key_aspect.id)
+
+    @property
+    def id(self) -> str:
+        return self.entity_ids[0]
+
+if TYPE_CHECKING:
+    from datahub.metadata.schema_classes import TelemetryKeyClass
+
+class TelemetryUrn(_SpecificUrn):
+    ENTITY_TYPE: ClassVar[str] = "telemetry"
+    URN_PARTS: ClassVar[int] = 1
+
+    def __init__(self, name: str, *, _allow_coercion: bool = True) -> None:
+        if _allow_coercion:
+            # Field coercion logic (if any is required).
+            name = UrnEncoder.encode_string(name)
+
+        # Validation logic.
+        if not name:
+            raise InvalidUrnError("TelemetryUrn name cannot be empty")
+        if UrnEncoder.contains_reserved_char(name):
+            raise InvalidUrnError(f'TelemetryUrn name contains reserved characters')
+
+        super().__init__(self.ENTITY_TYPE, [name])
+
+    @classmethod
+    def _parse_ids(cls, entity_ids: List[str]) -> "TelemetryUrn":
+        if len(entity_ids) != cls.URN_PARTS:
+            raise InvalidUrnError(f"TelemetryUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        return cls(name=entity_ids[0], _allow_coercion=False)
+
+    @classmethod
+    def underlying_key_aspect_type(cls) -> Type["TelemetryKeyClass"]:
+        from datahub.metadata.schema_classes import TelemetryKeyClass
+
+        return TelemetryKeyClass
+
+    def to_key_aspect(self) -> "TelemetryKeyClass":
+        from datahub.metadata.schema_classes import TelemetryKeyClass
+
+        return TelemetryKeyClass(name=self.name)
+
+    @classmethod
+    def from_key_aspect(cls, key_aspect: "TelemetryKeyClass") -> "TelemetryUrn":
+        return cls(name=key_aspect.name)
+
+    @property
+    def name(self) -> str:
+        return self.entity_ids[0]
+
 if TYPE_CHECKING:
     from datahub.metadata.schema_classes import MLModelKeyClass