acryl-datahub-cloud 0.3.8.3__py3-none-any.whl → 0.3.9__py3-none-any.whl

acryl_datahub_cloud/metadata/_urns/urn_defs.py

@@ -10,7 +10,7 @@
 
 # This file contains classes corresponding to entity URNs.
 
-from typing import ClassVar, List, Optional, Type, TYPE_CHECKING
+from typing import ClassVar, List, Optional, Type, TYPE_CHECKING, Union, Literal
 
 import functools
 from deprecated.sphinx import deprecated as _sphinx_deprecated
@@ -25,17 +25,28 @@ if TYPE_CHECKING:
     from datahub.metadata.schema_classes import DataProductKeyClass
 
 class DataProductUrn(_SpecificUrn):
-    ENTITY_TYPE: ClassVar[str] = "dataProduct"
-    URN_PARTS: ClassVar[int] = 1
+    ENTITY_TYPE: ClassVar[Literal["dataProduct"]] = "dataProduct"
+    _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["DataProductUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            id = UrnEncoder.encode_string(id)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = DataProductUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a DataProductUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not id:
             raise InvalidUrnError("DataProductUrn id cannot be empty")
+        if isinstance(id, DataProductUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a DataProductUrn but got {id}')
         if UrnEncoder.contains_reserved_char(id):
             raise InvalidUrnError(f'DataProductUrn id contains reserved characters')
 
@@ -43,8 +54,8 @@ class DataProductUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "DataProductUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"DataProductUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"DataProductUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(id=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -64,23 +75,34 @@ class DataProductUrn(_SpecificUrn):
 
     @property
     def id(self) -> str:
-        return self.entity_ids[0]
+        return self._entity_ids[0]
 
 if TYPE_CHECKING:
     from datahub.metadata.schema_classes import StructuredPropertyKeyClass
 
 class StructuredPropertyUrn(_SpecificUrn):
-    ENTITY_TYPE: ClassVar[str] = "structuredProperty"
-    URN_PARTS: ClassVar[int] = 1
+    ENTITY_TYPE: ClassVar[Literal["structuredProperty"]] = "structuredProperty"
+    _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["StructuredPropertyUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            id = UrnEncoder.encode_string(id)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = StructuredPropertyUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a StructuredPropertyUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not id:
             raise InvalidUrnError("StructuredPropertyUrn id cannot be empty")
+        if isinstance(id, StructuredPropertyUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a StructuredPropertyUrn but got {id}')
         if UrnEncoder.contains_reserved_char(id):
             raise InvalidUrnError(f'StructuredPropertyUrn id contains reserved characters')
 
@@ -88,8 +110,8 @@ class StructuredPropertyUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "StructuredPropertyUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"StructuredPropertyUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"StructuredPropertyUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(id=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -109,23 +131,34 @@ class StructuredPropertyUrn(_SpecificUrn):
 
     @property
     def id(self) -> str:
-        return self.entity_ids[0]
+        return self._entity_ids[0]
 
 if TYPE_CHECKING:
     from datahub.metadata.schema_classes import EntityTypeKeyClass
 
 class EntityTypeUrn(_SpecificUrn):
-    ENTITY_TYPE: ClassVar[str] = "entityType"
-    URN_PARTS: ClassVar[int] = 1
+    ENTITY_TYPE: ClassVar[Literal["entityType"]] = "entityType"
+    _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["EntityTypeUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            id = UrnEncoder.encode_string(id)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = EntityTypeUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a EntityTypeUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not id:
             raise InvalidUrnError("EntityTypeUrn id cannot be empty")
+        if isinstance(id, EntityTypeUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a EntityTypeUrn but got {id}')
         if UrnEncoder.contains_reserved_char(id):
             raise InvalidUrnError(f'EntityTypeUrn id contains reserved characters')
 
@@ -133,8 +166,8 @@ class EntityTypeUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "EntityTypeUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"EntityTypeUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"EntityTypeUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(id=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -154,23 +187,34 @@ class EntityTypeUrn(_SpecificUrn):
 
     @property
     def id(self) -> str:
-        return self.entity_ids[0]
+        return self._entity_ids[0]
 
 if TYPE_CHECKING:
     from datahub.metadata.schema_classes import PlatformResourceKeyClass
 
 class PlatformResourceUrn(_SpecificUrn):
-    ENTITY_TYPE: ClassVar[str] = "platformResource"
-    URN_PARTS: ClassVar[int] = 1
+    ENTITY_TYPE: ClassVar[Literal["platformResource"]] = "platformResource"
+    _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["PlatformResourceUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            id = UrnEncoder.encode_string(id)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = PlatformResourceUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a PlatformResourceUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not id:
             raise InvalidUrnError("PlatformResourceUrn id cannot be empty")
+        if isinstance(id, PlatformResourceUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a PlatformResourceUrn but got {id}')
         if UrnEncoder.contains_reserved_char(id):
             raise InvalidUrnError(f'PlatformResourceUrn id contains reserved characters')
 
@@ -178,8 +222,8 @@ class PlatformResourceUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "PlatformResourceUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"PlatformResourceUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"PlatformResourceUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(id=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -199,23 +243,34 @@ class PlatformResourceUrn(_SpecificUrn):
 
     @property
     def id(self) -> str:
-        return self.entity_ids[0]
+        return self._entity_ids[0]
 
 if TYPE_CHECKING:
     from datahub.metadata.schema_classes import BusinessAttributeKeyClass
 
 class BusinessAttributeUrn(_SpecificUrn):
-    ENTITY_TYPE: ClassVar[str] = "businessAttribute"
-    URN_PARTS: ClassVar[int] = 1
+    ENTITY_TYPE: ClassVar[Literal["businessAttribute"]] = "businessAttribute"
+    _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["BusinessAttributeUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            id = UrnEncoder.encode_string(id)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = BusinessAttributeUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a BusinessAttributeUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not id:
             raise InvalidUrnError("BusinessAttributeUrn id cannot be empty")
+        if isinstance(id, BusinessAttributeUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a BusinessAttributeUrn but got {id}')
         if UrnEncoder.contains_reserved_char(id):
             raise InvalidUrnError(f'BusinessAttributeUrn id contains reserved characters')
 
@@ -223,8 +278,8 @@ class BusinessAttributeUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "BusinessAttributeUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"BusinessAttributeUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"BusinessAttributeUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(id=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -244,23 +299,34 @@ class BusinessAttributeUrn(_SpecificUrn):
 
     @property
     def id(self) -> str:
-        return self.entity_ids[0]
+        return self._entity_ids[0]
 
 if TYPE_CHECKING:
     from datahub.metadata.schema_classes import DataTypeKeyClass
 
 class DataTypeUrn(_SpecificUrn):
-    ENTITY_TYPE: ClassVar[str] = "dataType"
-    URN_PARTS: ClassVar[int] = 1
+    ENTITY_TYPE: ClassVar[Literal["dataType"]] = "dataType"
+    _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["DataTypeUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            id = UrnEncoder.encode_string(id)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = DataTypeUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a DataTypeUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not id:
             raise InvalidUrnError("DataTypeUrn id cannot be empty")
+        if isinstance(id, DataTypeUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a DataTypeUrn but got {id}')
         if UrnEncoder.contains_reserved_char(id):
             raise InvalidUrnError(f'DataTypeUrn id contains reserved characters')
 
@@ -268,8 +334,8 @@ class DataTypeUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "DataTypeUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"DataTypeUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"DataTypeUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(id=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -289,23 +355,34 @@ class DataTypeUrn(_SpecificUrn):
 
     @property
     def id(self) -> str:
-        return self.entity_ids[0]
+        return self._entity_ids[0]
 
 if TYPE_CHECKING:
     from datahub.metadata.schema_classes import InviteTokenKeyClass
 
 class InviteTokenUrn(_SpecificUrn):
-    ENTITY_TYPE: ClassVar[str] = "inviteToken"
-    URN_PARTS: ClassVar[int] = 1
+    ENTITY_TYPE: ClassVar[Literal["inviteToken"]] = "inviteToken"
+    _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["InviteTokenUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            id = UrnEncoder.encode_string(id)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = InviteTokenUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a InviteTokenUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not id:
             raise InvalidUrnError("InviteTokenUrn id cannot be empty")
+        if isinstance(id, InviteTokenUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a InviteTokenUrn but got {id}')
         if UrnEncoder.contains_reserved_char(id):
             raise InvalidUrnError(f'InviteTokenUrn id contains reserved characters')
 
@@ -313,8 +390,8 @@ class InviteTokenUrn(_SpecificUrn):
 
     @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}")
+        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
@@ -334,23 +411,34 @@ class InviteTokenUrn(_SpecificUrn):
 
     @property
     def id(self) -> str:
-        return self.entity_ids[0]
+        return self._entity_ids[0]
 
 if TYPE_CHECKING:
     from datahub.metadata.schema_classes import AssertionKeyClass
 
 class AssertionUrn(_SpecificUrn):
-    ENTITY_TYPE: ClassVar[str] = "assertion"
-    URN_PARTS: ClassVar[int] = 1
+    ENTITY_TYPE: ClassVar[Literal["assertion"]] = "assertion"
+    _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, assertion_id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, assertion_id: Union["AssertionUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            assertion_id = UrnEncoder.encode_string(assertion_id)
+            if isinstance(assertion_id, str):
+                if assertion_id.startswith('urn:li:'):
+                    try:
+                        assertion_id = AssertionUrn.from_string(assertion_id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a AssertionUrn but got {assertion_id}')
+                else:
+                    assertion_id = UrnEncoder.encode_string(assertion_id)
 
         # Validation logic.
         if not assertion_id:
             raise InvalidUrnError("AssertionUrn assertion_id cannot be empty")
+        if isinstance(assertion_id, AssertionUrn):
+            assertion_id = assertion_id.assertion_id
+        elif isinstance(assertion_id, Urn):
+            raise InvalidUrnError(f'Expecting a AssertionUrn but got {assertion_id}')
         if UrnEncoder.contains_reserved_char(assertion_id):
             raise InvalidUrnError(f'AssertionUrn assertion_id contains reserved characters')
 
@@ -358,8 +446,8 @@ class AssertionUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "AssertionUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"AssertionUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"AssertionUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(assertion_id=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -379,24 +467,32 @@ class AssertionUrn(_SpecificUrn):
 
     @property
     def assertion_id(self) -> str:
-        return self.entity_ids[0]
+        return self._entity_ids[0]
 
 if TYPE_CHECKING:
     from datahub.metadata.schema_classes import SchemaFieldKeyClass
 
 class SchemaFieldUrn(_SpecificUrn):
-    ENTITY_TYPE: ClassVar[str] = "schemaField"
-    URN_PARTS: ClassVar[int] = 2
+    ENTITY_TYPE: ClassVar[Literal["schemaField"]] = "schemaField"
+    _URN_PARTS: ClassVar[int] = 2
 
-    def __init__(self, parent: str, field_path: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, parent: Union["Urn", str], field_path: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
+            if isinstance(parent, str):
+                if parent.startswith('urn:li:'):
+                    try:
+                        parent = Urn.from_string(parent)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a Urn but got {parent}')
+                else:
+                    parent = UrnEncoder.encode_string(parent)
             field_path = UrnEncoder.encode_string(field_path)
 
         # Validation logic.
         if not parent:
             raise InvalidUrnError("SchemaFieldUrn parent cannot be empty")
-        parent = str(parent)
+        parent = str(parent)  # convert urn type to str
         assert Urn.from_string(parent)
         if not field_path:
             raise InvalidUrnError("SchemaFieldUrn field_path cannot be empty")
@@ -407,8 +503,8 @@ class SchemaFieldUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "SchemaFieldUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"SchemaFieldUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"SchemaFieldUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(parent=entity_ids[0], field_path=entity_ids[1], _allow_coercion=False)
 
     @classmethod
@@ -428,27 +524,38 @@ class SchemaFieldUrn(_SpecificUrn):
 
     @property
     def parent(self) -> str:
-        return self.entity_ids[0]
+        return self._entity_ids[0]
 
     @property
     def field_path(self) -> str:
-        return self.entity_ids[1]
+        return self._entity_ids[1]
 
 if TYPE_CHECKING:
     from datahub.metadata.schema_classes import CorpGroupKeyClass
 
 class CorpGroupUrn(_SpecificUrn):
-    ENTITY_TYPE: ClassVar[str] = "corpGroup"
-    URN_PARTS: ClassVar[int] = 1
+    ENTITY_TYPE: ClassVar[Literal["corpGroup"]] = "corpGroup"
+    _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, name: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, name: Union["CorpGroupUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            name = UrnEncoder.encode_string(name)
+            if isinstance(name, str):
+                if name.startswith('urn:li:'):
+                    try:
+                        name = CorpGroupUrn.from_string(name)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a CorpGroupUrn but got {name}')
+                else:
+                    name = UrnEncoder.encode_string(name)
 
         # Validation logic.
         if not name:
             raise InvalidUrnError("CorpGroupUrn name cannot be empty")
+        if isinstance(name, CorpGroupUrn):
+            name = name.name
+        elif isinstance(name, Urn):
+            raise InvalidUrnError(f'Expecting a CorpGroupUrn but got {name}')
         if UrnEncoder.contains_reserved_char(name):
             raise InvalidUrnError(f'CorpGroupUrn name contains reserved characters')
 
@@ -456,8 +563,8 @@ class CorpGroupUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "CorpGroupUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"CorpGroupUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"CorpGroupUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(name=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -482,23 +589,34 @@ class CorpGroupUrn(_SpecificUrn):
 
     @property
     def name(self) -> str:
-        return self.entity_ids[0]
+        return self._entity_ids[0]
 
 if TYPE_CHECKING:
     from datahub.metadata.schema_classes import RoleKeyClass
 
 class RoleUrn(_SpecificUrn):
-    ENTITY_TYPE: ClassVar[str] = "role"
-    URN_PARTS: ClassVar[int] = 1
+    ENTITY_TYPE: ClassVar[Literal["role"]] = "role"
+    _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["RoleUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            id = UrnEncoder.encode_string(id)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = RoleUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a RoleUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not id:
             raise InvalidUrnError("RoleUrn id cannot be empty")
+        if isinstance(id, RoleUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a RoleUrn but got {id}')
         if UrnEncoder.contains_reserved_char(id):
             raise InvalidUrnError(f'RoleUrn id contains reserved characters')
 
@@ -506,8 +624,8 @@ class RoleUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "RoleUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"RoleUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"RoleUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(id=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -527,23 +645,34 @@ class RoleUrn(_SpecificUrn):
 
     @property
     def id(self) -> str:
-        return self.entity_ids[0]
+        return self._entity_ids[0]
 
 if TYPE_CHECKING:
     from datahub.metadata.schema_classes import DataProcessInstanceKeyClass
 
 class DataProcessInstanceUrn(_SpecificUrn):
-    ENTITY_TYPE: ClassVar[str] = "dataProcessInstance"
-    URN_PARTS: ClassVar[int] = 1
+    ENTITY_TYPE: ClassVar[Literal["dataProcessInstance"]] = "dataProcessInstance"
+    _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["DataProcessInstanceUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            id = UrnEncoder.encode_string(id)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = DataProcessInstanceUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a DataProcessInstanceUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not id:
             raise InvalidUrnError("DataProcessInstanceUrn id cannot be empty")
+        if isinstance(id, DataProcessInstanceUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a DataProcessInstanceUrn but got {id}')
         if UrnEncoder.contains_reserved_char(id):
             raise InvalidUrnError(f'DataProcessInstanceUrn id contains reserved characters')
 
@@ -551,8 +680,8 @@ class DataProcessInstanceUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "DataProcessInstanceUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"DataProcessInstanceUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"DataProcessInstanceUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(id=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -581,23 +710,34 @@ class DataProcessInstanceUrn(_SpecificUrn):
 
     @property
     def id(self) -> str:
-        return self.entity_ids[0]
+        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
+    ENTITY_TYPE: ClassVar[Literal["dataHubSecret"]] = "dataHubSecret"
+    _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["DataHubSecretUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            id = UrnEncoder.encode_string(id)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = DataHubSecretUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a DataHubSecretUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not id:
             raise InvalidUrnError("DataHubSecretUrn id cannot be empty")
+        if isinstance(id, DataHubSecretUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a DataHubSecretUrn but got {id}')
         if UrnEncoder.contains_reserved_char(id):
             raise InvalidUrnError(f'DataHubSecretUrn id contains reserved characters')
 
@@ -605,8 +745,8 @@ class DataHubSecretUrn(_SpecificUrn):
 
     @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}")
+        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
@@ -626,23 +766,34 @@ class DataHubSecretUrn(_SpecificUrn):
 
     @property
     def id(self) -> str:
-        return self.entity_ids[0]
+        return self._entity_ids[0]
 
 if TYPE_CHECKING:
     from datahub.metadata.schema_classes import DataHubPersonaKeyClass
 
 class DataHubPersonaUrn(_SpecificUrn):
-    ENTITY_TYPE: ClassVar[str] = "dataHubPersona"
-    URN_PARTS: ClassVar[int] = 1
+    ENTITY_TYPE: ClassVar[Literal["dataHubPersona"]] = "dataHubPersona"
+    _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["DataHubPersonaUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            id = UrnEncoder.encode_string(id)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = DataHubPersonaUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a DataHubPersonaUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not id:
             raise InvalidUrnError("DataHubPersonaUrn id cannot be empty")
+        if isinstance(id, DataHubPersonaUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a DataHubPersonaUrn but got {id}')
         if UrnEncoder.contains_reserved_char(id):
             raise InvalidUrnError(f'DataHubPersonaUrn id contains reserved characters')
 
@@ -650,8 +801,8 @@ class DataHubPersonaUrn(_SpecificUrn):
 
     @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}")
+        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
@@ -671,16 +822,16 @@ class DataHubPersonaUrn(_SpecificUrn):
 
     @property
     def id(self) -> str:
-        return self.entity_ids[0]
+        return self._entity_ids[0]
 
 if TYPE_CHECKING:
     from datahub.metadata.schema_classes import MLFeatureTableKeyClass
 
 class MlFeatureTableUrn(_SpecificUrn):
-    ENTITY_TYPE: ClassVar[str] = "mlFeatureTable"
-    URN_PARTS: ClassVar[int] = 2
+    ENTITY_TYPE: ClassVar[Literal["mlFeatureTable"]] = "mlFeatureTable"
+    _URN_PARTS: ClassVar[int] = 2
 
-    def __init__(self, platform: str, name: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, platform: Union["DataPlatformUrn", str], name: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
             platform = DataPlatformUrn(platform).urn()
@@ -689,7 +840,7 @@ class MlFeatureTableUrn(_SpecificUrn):
         # Validation logic.
         if not platform:
             raise InvalidUrnError("MlFeatureTableUrn platform cannot be empty")
-        platform = str(platform)
+        platform = str(platform)  # convert urn type to str
         assert DataPlatformUrn.from_string(platform)
         if not name:
             raise InvalidUrnError("MlFeatureTableUrn name cannot be empty")
@@ -700,8 +851,8 @@ class MlFeatureTableUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "MlFeatureTableUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"MlFeatureTableUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"MlFeatureTableUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(platform=entity_ids[0], name=entity_ids[1], _allow_coercion=False)
 
     @classmethod
@@ -721,27 +872,38 @@ class MlFeatureTableUrn(_SpecificUrn):
 
     @property
     def platform(self) -> str:
-        return self.entity_ids[0]
+        return self._entity_ids[0]
 
     @property
     def name(self) -> str:
-        return self.entity_ids[1]
+        return self._entity_ids[1]
 
 if TYPE_CHECKING:
     from datahub.metadata.schema_classes import GlossaryTermKeyClass
 
 class GlossaryTermUrn(_SpecificUrn):
-    ENTITY_TYPE: ClassVar[str] = "glossaryTerm"
-    URN_PARTS: ClassVar[int] = 1
+    ENTITY_TYPE: ClassVar[Literal["glossaryTerm"]] = "glossaryTerm"
+    _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, name: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, name: Union["GlossaryTermUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            name = UrnEncoder.encode_string(name)
+            if isinstance(name, str):
+                if name.startswith('urn:li:'):
+                    try:
+                        name = GlossaryTermUrn.from_string(name)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a GlossaryTermUrn but got {name}')
+                else:
+                    name = UrnEncoder.encode_string(name)
 
         # Validation logic.
         if not name:
             raise InvalidUrnError("GlossaryTermUrn name cannot be empty")
+        if isinstance(name, GlossaryTermUrn):
+            name = name.name
+        elif isinstance(name, Urn):
+            raise InvalidUrnError(f'Expecting a GlossaryTermUrn but got {name}')
         if UrnEncoder.contains_reserved_char(name):
             raise InvalidUrnError(f'GlossaryTermUrn name contains reserved characters')
 
@@ -749,8 +911,8 @@ class GlossaryTermUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "GlossaryTermUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"GlossaryTermUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"GlossaryTermUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(name=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -770,14 +932,14 @@ class GlossaryTermUrn(_SpecificUrn):
 
     @property
     def name(self) -> str:
-        return self.entity_ids[0]
+        return self._entity_ids[0]
 
 if TYPE_CHECKING:
     from datahub.metadata.schema_classes import RecommendationModuleKeyClass
 
 class RecommendationModuleUrn(_SpecificUrn):
-    ENTITY_TYPE: ClassVar[str] = "recommendationModule"
-    URN_PARTS: ClassVar[int] = 2
+    ENTITY_TYPE: ClassVar[Literal["recommendationModule"]] = "recommendationModule"
+    _URN_PARTS: ClassVar[int] = 2
 
     def __init__(self, module_id: str, identifier: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
@@ -799,8 +961,8 @@ class RecommendationModuleUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "RecommendationModuleUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"RecommendationModuleUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"RecommendationModuleUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(module_id=entity_ids[0], identifier=entity_ids[1], _allow_coercion=False)
 
     @classmethod
@@ -820,27 +982,38 @@ class RecommendationModuleUrn(_SpecificUrn):
 
     @property
     def module_id(self) -> str:
-        return self.entity_ids[0]
+        return self._entity_ids[0]
 
     @property
     def identifier(self) -> str:
-        return self.entity_ids[1]
+        return self._entity_ids[1]
 
 if TYPE_CHECKING:
     from datahub.metadata.schema_classes import PostKeyClass
 
 class PostUrn(_SpecificUrn):
-    ENTITY_TYPE: ClassVar[str] = "post"
-    URN_PARTS: ClassVar[int] = 1
+    ENTITY_TYPE: ClassVar[Literal["post"]] = "post"
+    _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["PostUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            id = UrnEncoder.encode_string(id)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = PostUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a PostUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not id:
             raise InvalidUrnError("PostUrn id cannot be empty")
+        if isinstance(id, PostUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a PostUrn but got {id}')
         if UrnEncoder.contains_reserved_char(id):
             raise InvalidUrnError(f'PostUrn id contains reserved characters')
 
@@ -848,8 +1021,8 @@ class PostUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "PostUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"PostUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"PostUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(id=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -869,14 +1042,14 @@ class PostUrn(_SpecificUrn):
 
     @property
     def id(self) -> str:
-        return self.entity_ids[0]
+        return self._entity_ids[0]
 
 if TYPE_CHECKING:
     from datahub.metadata.schema_classes import MLPrimaryKeyKeyClass
 
 class MlPrimaryKeyUrn(_SpecificUrn):
-    ENTITY_TYPE: ClassVar[str] = "mlPrimaryKey"
-    URN_PARTS: ClassVar[int] = 2
+    ENTITY_TYPE: ClassVar[Literal["mlPrimaryKey"]] = "mlPrimaryKey"
+    _URN_PARTS: ClassVar[int] = 2
 
     def __init__(self, feature_namespace: str, name: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
@@ -898,8 +1071,8 @@ class MlPrimaryKeyUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "MlPrimaryKeyUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"MlPrimaryKeyUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"MlPrimaryKeyUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(feature_namespace=entity_ids[0], name=entity_ids[1], _allow_coercion=False)
 
     @classmethod
@@ -919,20 +1092,20 @@ class MlPrimaryKeyUrn(_SpecificUrn):
 
     @property
     def feature_namespace(self) -> str:
-        return self.entity_ids[0]
+        return self._entity_ids[0]
 
     @property
     def name(self) -> str:
-        return self.entity_ids[1]
+        return self._entity_ids[1]
 
 if TYPE_CHECKING:
     from datahub.metadata.schema_classes import DataPlatformInstanceKeyClass
 
 class DataPlatformInstanceUrn(_SpecificUrn):
-    ENTITY_TYPE: ClassVar[str] = "dataPlatformInstance"
-    URN_PARTS: ClassVar[int] = 2
+    ENTITY_TYPE: ClassVar[Literal["dataPlatformInstance"]] = "dataPlatformInstance"
+    _URN_PARTS: ClassVar[int] = 2
 
-    def __init__(self, platform: str, instance: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, platform: Union["DataPlatformUrn", str], instance: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
             platform = DataPlatformUrn(platform).urn()
@@ -941,7 +1114,7 @@ class DataPlatformInstanceUrn(_SpecificUrn):
         # Validation logic.
         if not platform:
             raise InvalidUrnError("DataPlatformInstanceUrn platform cannot be empty")
-        platform = str(platform)
+        platform = str(platform)  # convert urn type to str
         assert DataPlatformUrn.from_string(platform)
         if not instance:
             raise InvalidUrnError("DataPlatformInstanceUrn instance cannot be empty")
@@ -952,8 +1125,8 @@ class DataPlatformInstanceUrn(_SpecificUrn):
 
     @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}")
+        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
@@ -973,27 +1146,94 @@ class DataPlatformInstanceUrn(_SpecificUrn):
 
     @property
     def platform(self) -> str:
-        return self.entity_ids[0]
+        return self._entity_ids[0]
 
     @property
     def instance(self) -> str:
-        return self.entity_ids[1]
+        return self._entity_ids[1]
+
+if TYPE_CHECKING:
+    from datahub.metadata.schema_classes import DataHubMetricCubeKeyClass
+
+class DataHubMetricCubeUrn(_SpecificUrn):
+    ENTITY_TYPE: ClassVar[Literal["dataHubMetricCube"]] = "dataHubMetricCube"
+    _URN_PARTS: ClassVar[int] = 1
+
+    def __init__(self, id: Union["DataHubMetricCubeUrn", str], *, _allow_coercion: bool = True) -> None:
+        if _allow_coercion:
+            # Field coercion logic (if any is required).
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = DataHubMetricCubeUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a DataHubMetricCubeUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
+
+        # Validation logic.
+        if not id:
+            raise InvalidUrnError("DataHubMetricCubeUrn id cannot be empty")
+        if isinstance(id, DataHubMetricCubeUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a DataHubMetricCubeUrn but got {id}')
+        if UrnEncoder.contains_reserved_char(id):
+            raise InvalidUrnError(f'DataHubMetricCubeUrn id contains reserved characters')
+
+        super().__init__(self.ENTITY_TYPE, [id])
+
+    @classmethod
+    def _parse_ids(cls, entity_ids: List[str]) -> "DataHubMetricCubeUrn":
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"DataHubMetricCubeUrn 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["DataHubMetricCubeKeyClass"]:
+        from datahub.metadata.schema_classes import DataHubMetricCubeKeyClass
+
+        return DataHubMetricCubeKeyClass
+
+    def to_key_aspect(self) -> "DataHubMetricCubeKeyClass":
+        from datahub.metadata.schema_classes import DataHubMetricCubeKeyClass
+
+        return DataHubMetricCubeKeyClass(id=self.id)
+
+    @classmethod
+    def from_key_aspect(cls, key_aspect: "DataHubMetricCubeKeyClass") -> "DataHubMetricCubeUrn":
+        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 QueryKeyClass
 
 class QueryUrn(_SpecificUrn):
-    ENTITY_TYPE: ClassVar[str] = "query"
-    URN_PARTS: ClassVar[int] = 1
+    ENTITY_TYPE: ClassVar[Literal["query"]] = "query"
+    _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["QueryUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            id = UrnEncoder.encode_string(id)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = QueryUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a QueryUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not id:
             raise InvalidUrnError("QueryUrn id cannot be empty")
+        if isinstance(id, QueryUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a QueryUrn but got {id}')
         if UrnEncoder.contains_reserved_char(id):
             raise InvalidUrnError(f'QueryUrn id contains reserved characters')
 
@@ -1001,8 +1241,8 @@ class QueryUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "QueryUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"QueryUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"QueryUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(id=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -1022,27 +1262,26 @@ class QueryUrn(_SpecificUrn):
 
     @property
     def id(self) -> str:
-        return self.entity_ids[0]
+        return self._entity_ids[0]
 
 if TYPE_CHECKING:
     from datahub.metadata.schema_classes import DatasetKeyClass
 
 class DatasetUrn(_SpecificUrn):
-    ENTITY_TYPE: ClassVar[str] = "dataset"
-    URN_PARTS: ClassVar[int] = 3
+    ENTITY_TYPE: ClassVar[Literal["dataset"]] = "dataset"
+    _URN_PARTS: ClassVar[int] = 3
 
-    def __init__(self, platform: str, name: str, env: str = "PROD", *, _allow_coercion: bool = True) -> None:
+    def __init__(self, platform: Union["DataPlatformUrn", str], name: str, env: str = "PROD", *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
             platform = DataPlatformUrn(platform).urn()
             name = UrnEncoder.encode_string(name)
             env = env.upper()
-            env = UrnEncoder.encode_string(env)
 
         # Validation logic.
         if not platform:
             raise InvalidUrnError("DatasetUrn platform cannot be empty")
-        platform = str(platform)
+        platform = str(platform)  # convert urn type to str
         assert DataPlatformUrn.from_string(platform)
         if not name:
             raise InvalidUrnError("DatasetUrn name cannot be empty")
@@ -1057,8 +1296,8 @@ class DatasetUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "DatasetUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"DatasetUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"DatasetUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(platform=entity_ids[0], name=entity_ids[1], env=entity_ids[2], _allow_coercion=False)
 
     @classmethod
@@ -1107,31 +1346,42 @@ class DatasetUrn(_SpecificUrn):
 
     @property
     def platform(self) -> str:
-        return self.entity_ids[0]
+        return self._entity_ids[0]
 
     @property
     def name(self) -> str:
-        return self.entity_ids[1]
+        return self._entity_ids[1]
 
     @property
     def env(self) -> str:
-        return self.entity_ids[2]
+        return self._entity_ids[2]
 
 if TYPE_CHECKING:
     from datahub.metadata.schema_classes import ExecutionRequestKeyClass
 
 class DataHubExecutionRequestUrn(_SpecificUrn):
-    ENTITY_TYPE: ClassVar[str] = "dataHubExecutionRequest"
-    URN_PARTS: ClassVar[int] = 1
+    ENTITY_TYPE: ClassVar[Literal["dataHubExecutionRequest"]] = "dataHubExecutionRequest"
+    _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["DataHubExecutionRequestUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            id = UrnEncoder.encode_string(id)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = DataHubExecutionRequestUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a DataHubExecutionRequestUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not id:
             raise InvalidUrnError("DataHubExecutionRequestUrn id cannot be empty")
+        if isinstance(id, DataHubExecutionRequestUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a DataHubExecutionRequestUrn but got {id}')
         if UrnEncoder.contains_reserved_char(id):
             raise InvalidUrnError(f'DataHubExecutionRequestUrn id contains reserved characters')
 
@@ -1139,8 +1389,8 @@ class DataHubExecutionRequestUrn(_SpecificUrn):
 
     @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}")
+        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
@@ -1160,14 +1410,14 @@ class DataHubExecutionRequestUrn(_SpecificUrn):
 
     @property
     def id(self) -> str:
-        return self.entity_ids[0]
+        return self._entity_ids[0]
 
 if TYPE_CHECKING:
     from datahub.metadata.schema_classes import ChartKeyClass
 
 class ChartUrn(_SpecificUrn):
-    ENTITY_TYPE: ClassVar[str] = "chart"
-    URN_PARTS: ClassVar[int] = 2
+    ENTITY_TYPE: ClassVar[Literal["chart"]] = "chart"
+    _URN_PARTS: ClassVar[int] = 2
 
     def __init__(self, dashboard_tool: str, chart_id: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
@@ -1189,8 +1439,8 @@ class ChartUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "ChartUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"ChartUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"ChartUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(dashboard_tool=entity_ids[0], chart_id=entity_ids[1], _allow_coercion=False)
 
     @classmethod
@@ -1210,31 +1460,30 @@ class ChartUrn(_SpecificUrn):
 
     @property
     def dashboard_tool(self) -> str:
-        return self.entity_ids[0]
+        return self._entity_ids[0]
 
     @property
     def chart_id(self) -> str:
-        return self.entity_ids[1]
+        return self._entity_ids[1]
 
 if TYPE_CHECKING:
     from datahub.metadata.schema_classes import MLModelGroupKeyClass
 
 class MlModelGroupUrn(_SpecificUrn):
-    ENTITY_TYPE: ClassVar[str] = "mlModelGroup"
-    URN_PARTS: ClassVar[int] = 3
+    ENTITY_TYPE: ClassVar[Literal["mlModelGroup"]] = "mlModelGroup"
+    _URN_PARTS: ClassVar[int] = 3
 
-    def __init__(self, platform: str, name: str, env: str = "PROD", *, _allow_coercion: bool = True) -> None:
+    def __init__(self, platform: Union["DataPlatformUrn", str], name: str, env: str = "PROD", *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
             platform = DataPlatformUrn(platform).urn()
             name = UrnEncoder.encode_string(name)
             env = env.upper()
-            env = UrnEncoder.encode_string(env)
 
         # Validation logic.
         if not platform:
             raise InvalidUrnError("MlModelGroupUrn platform cannot be empty")
-        platform = str(platform)
+        platform = str(platform)  # convert urn type to str
         assert DataPlatformUrn.from_string(platform)
         if not name:
             raise InvalidUrnError("MlModelGroupUrn name cannot be empty")
@@ -1249,8 +1498,8 @@ class MlModelGroupUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "MlModelGroupUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"MlModelGroupUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"MlModelGroupUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(platform=entity_ids[0], name=entity_ids[1], env=entity_ids[2], _allow_coercion=False)
 
     @classmethod
@@ -1270,31 +1519,42 @@ class MlModelGroupUrn(_SpecificUrn):
 
     @property
     def platform(self) -> str:
-        return self.entity_ids[0]
+        return self._entity_ids[0]
 
     @property
     def name(self) -> str:
-        return self.entity_ids[1]
+        return self._entity_ids[1]
 
     @property
     def env(self) -> str:
-        return self.entity_ids[2]
+        return self._entity_ids[2]
 
 if TYPE_CHECKING:
     from datahub.metadata.schema_classes import SubscriptionKeyClass
 
 class SubscriptionUrn(_SpecificUrn):
-    ENTITY_TYPE: ClassVar[str] = "subscription"
-    URN_PARTS: ClassVar[int] = 1
+    ENTITY_TYPE: ClassVar[Literal["subscription"]] = "subscription"
+    _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["SubscriptionUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            id = UrnEncoder.encode_string(id)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = SubscriptionUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a SubscriptionUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not id:
             raise InvalidUrnError("SubscriptionUrn id cannot be empty")
+        if isinstance(id, SubscriptionUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a SubscriptionUrn but got {id}')
         if UrnEncoder.contains_reserved_char(id):
             raise InvalidUrnError(f'SubscriptionUrn id contains reserved characters')
 
@@ -1302,8 +1562,8 @@ class SubscriptionUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "SubscriptionUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"SubscriptionUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"SubscriptionUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(id=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -1323,23 +1583,34 @@ class SubscriptionUrn(_SpecificUrn):
 
     @property
     def id(self) -> str:
-        return self.entity_ids[0]
+        return self._entity_ids[0]
 
 if TYPE_CHECKING:
     from datahub.metadata.schema_classes import AnomalyKeyClass
 
 class AnomalyUrn(_SpecificUrn):
-    ENTITY_TYPE: ClassVar[str] = "anomaly"
-    URN_PARTS: ClassVar[int] = 1
+    ENTITY_TYPE: ClassVar[Literal["anomaly"]] = "anomaly"
+    _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["AnomalyUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            id = UrnEncoder.encode_string(id)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = AnomalyUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a AnomalyUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not id:
             raise InvalidUrnError("AnomalyUrn id cannot be empty")
+        if isinstance(id, AnomalyUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a AnomalyUrn but got {id}')
         if UrnEncoder.contains_reserved_char(id):
             raise InvalidUrnError(f'AnomalyUrn id contains reserved characters')
 
@@ -1347,8 +1618,8 @@ class AnomalyUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "AnomalyUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"AnomalyUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"AnomalyUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(id=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -1368,33 +1639,44 @@ class AnomalyUrn(_SpecificUrn):
 
     @property
     def id(self) -> str:
-        return self.entity_ids[0]
+        return self._entity_ids[0]
 
 if TYPE_CHECKING:
     from datahub.metadata.schema_classes import RemoteExecutorPoolKeyClass
 
 class DataHubRemoteExecutorPoolUrn(_SpecificUrn):
-    ENTITY_TYPE: ClassVar[str] = "dataHubRemoteExecutorPool"
-    URN_PARTS: ClassVar[int] = 1
+    ENTITY_TYPE: ClassVar[Literal["dataHubRemoteExecutorPool"]] = "dataHubRemoteExecutorPool"
+    _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, name: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["DataHubRemoteExecutorPoolUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            name = UrnEncoder.encode_string(name)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = DataHubRemoteExecutorPoolUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a DataHubRemoteExecutorPoolUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
-        if not name:
-            raise InvalidUrnError("DataHubRemoteExecutorPoolUrn name cannot be empty")
-        if UrnEncoder.contains_reserved_char(name):
-            raise InvalidUrnError(f'DataHubRemoteExecutorPoolUrn name contains reserved characters')
+        if not id:
+            raise InvalidUrnError("DataHubRemoteExecutorPoolUrn id cannot be empty")
+        if isinstance(id, DataHubRemoteExecutorPoolUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a DataHubRemoteExecutorPoolUrn but got {id}')
+        if UrnEncoder.contains_reserved_char(id):
+            raise InvalidUrnError(f'DataHubRemoteExecutorPoolUrn id contains reserved characters')
 
-        super().__init__(self.ENTITY_TYPE, [name])
+        super().__init__(self.ENTITY_TYPE, [id])
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "DataHubRemoteExecutorPoolUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"DataHubRemoteExecutorPoolUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
-        return cls(name=entity_ids[0], _allow_coercion=False)
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"DataHubRemoteExecutorPoolUrn 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["RemoteExecutorPoolKeyClass"]:
@@ -1405,32 +1687,40 @@ class DataHubRemoteExecutorPoolUrn(_SpecificUrn):
     def to_key_aspect(self) -> "RemoteExecutorPoolKeyClass":
         from datahub.metadata.schema_classes import RemoteExecutorPoolKeyClass
 
-        return RemoteExecutorPoolKeyClass(name=self.name)
+        return RemoteExecutorPoolKeyClass(id=self.id)
 
     @classmethod
     def from_key_aspect(cls, key_aspect: "RemoteExecutorPoolKeyClass") -> "DataHubRemoteExecutorPoolUrn":
-        return cls(name=key_aspect.name)
+        return cls(id=key_aspect.id)
 
     @property
-    def name(self) -> str:
-        return self.entity_ids[0]
+    def id(self) -> str:
+        return self._entity_ids[0]
 
 if TYPE_CHECKING:
     from datahub.metadata.schema_classes import DataJobKeyClass
 
 class DataJobUrn(_SpecificUrn):
-    ENTITY_TYPE: ClassVar[str] = "dataJob"
-    URN_PARTS: ClassVar[int] = 2
+    ENTITY_TYPE: ClassVar[Literal["dataJob"]] = "dataJob"
+    _URN_PARTS: ClassVar[int] = 2
 
-    def __init__(self, flow: str, job_id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, flow: Union["DataFlowUrn", str], job_id: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
+            if isinstance(flow, str):
+                if flow.startswith('urn:li:'):
+                    try:
+                        flow = DataFlowUrn.from_string(flow)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a DataFlowUrn but got {flow}')
+                else:
+                    flow = UrnEncoder.encode_string(flow)
             job_id = UrnEncoder.encode_string(job_id)
 
         # Validation logic.
         if not flow:
             raise InvalidUrnError("DataJobUrn flow cannot be empty")
-        flow = str(flow)
+        flow = str(flow)  # convert urn type to str
         assert DataFlowUrn.from_string(flow)
         if not job_id:
             raise InvalidUrnError("DataJobUrn job_id cannot be empty")
@@ -1441,8 +1731,8 @@ class DataJobUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "DataJobUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"DataJobUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"DataJobUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(flow=entity_ids[0], job_id=entity_ids[1], _allow_coercion=False)
 
     @classmethod
@@ -1473,27 +1763,38 @@ class DataJobUrn(_SpecificUrn):
 
     @property
     def flow(self) -> str:
-        return self.entity_ids[0]
+        return self._entity_ids[0]
 
     @property
     def job_id(self) -> str:
-        return self.entity_ids[1]
+        return self._entity_ids[1]
 
 if TYPE_CHECKING:
     from datahub.metadata.schema_classes import DomainKeyClass
 
 class DomainUrn(_SpecificUrn):
-    ENTITY_TYPE: ClassVar[str] = "domain"
-    URN_PARTS: ClassVar[int] = 1
+    ENTITY_TYPE: ClassVar[Literal["domain"]] = "domain"
+    _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["DomainUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            id = UrnEncoder.encode_string(id)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = DomainUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a DomainUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not id:
             raise InvalidUrnError("DomainUrn id cannot be empty")
+        if isinstance(id, DomainUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a DomainUrn but got {id}')
         if UrnEncoder.contains_reserved_char(id):
             raise InvalidUrnError(f'DomainUrn id contains reserved characters')
 
@@ -1501,8 +1802,8 @@ class DomainUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "DomainUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"DomainUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"DomainUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(id=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -1527,23 +1828,34 @@ class DomainUrn(_SpecificUrn):
 
     @property
     def id(self) -> str:
-        return self.entity_ids[0]
+        return self._entity_ids[0]
 
 if TYPE_CHECKING:
     from datahub.metadata.schema_classes import ERModelRelationshipKeyClass
 
 class ErModelRelationshipUrn(_SpecificUrn):
-    ENTITY_TYPE: ClassVar[str] = "erModelRelationship"
-    URN_PARTS: ClassVar[int] = 1
+    ENTITY_TYPE: ClassVar[Literal["erModelRelationship"]] = "erModelRelationship"
+    _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["ErModelRelationshipUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            id = UrnEncoder.encode_string(id)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = ErModelRelationshipUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a ErModelRelationshipUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not id:
             raise InvalidUrnError("ErModelRelationshipUrn id cannot be empty")
+        if isinstance(id, ErModelRelationshipUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a ErModelRelationshipUrn but got {id}')
         if UrnEncoder.contains_reserved_char(id):
             raise InvalidUrnError(f'ErModelRelationshipUrn id contains reserved characters')
 
@@ -1551,8 +1863,8 @@ class ErModelRelationshipUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "ErModelRelationshipUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"ErModelRelationshipUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"ErModelRelationshipUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(id=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -1572,23 +1884,34 @@ class ErModelRelationshipUrn(_SpecificUrn):
 
     @property
     def id(self) -> str:
-        return self.entity_ids[0]
+        return self._entity_ids[0]
 
 if TYPE_CHECKING:
     from datahub.metadata.schema_classes import DataHubRoleKeyClass
 
 class DataHubRoleUrn(_SpecificUrn):
-    ENTITY_TYPE: ClassVar[str] = "dataHubRole"
-    URN_PARTS: ClassVar[int] = 1
+    ENTITY_TYPE: ClassVar[Literal["dataHubRole"]] = "dataHubRole"
+    _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["DataHubRoleUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            id = UrnEncoder.encode_string(id)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = DataHubRoleUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a DataHubRoleUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not id:
             raise InvalidUrnError("DataHubRoleUrn id cannot be empty")
+        if isinstance(id, DataHubRoleUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a DataHubRoleUrn but got {id}')
         if UrnEncoder.contains_reserved_char(id):
             raise InvalidUrnError(f'DataHubRoleUrn id contains reserved characters')
 
@@ -1596,8 +1919,8 @@ class DataHubRoleUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "DataHubRoleUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"DataHubRoleUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"DataHubRoleUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(id=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -1617,23 +1940,34 @@ class DataHubRoleUrn(_SpecificUrn):
 
     @property
     def id(self) -> str:
-        return self.entity_ids[0]
+        return self._entity_ids[0]
 
 if TYPE_CHECKING:
     from datahub.metadata.schema_classes import FormKeyClass
 
 class FormUrn(_SpecificUrn):
-    ENTITY_TYPE: ClassVar[str] = "form"
-    URN_PARTS: ClassVar[int] = 1
+    ENTITY_TYPE: ClassVar[Literal["form"]] = "form"
+    _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["FormUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            id = UrnEncoder.encode_string(id)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = FormUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a FormUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not id:
             raise InvalidUrnError("FormUrn id cannot be empty")
+        if isinstance(id, FormUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a FormUrn but got {id}')
         if UrnEncoder.contains_reserved_char(id):
             raise InvalidUrnError(f'FormUrn id contains reserved characters')
 
@@ -1641,8 +1975,8 @@ class FormUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "FormUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"FormUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"FormUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(id=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -1662,23 +1996,34 @@ class FormUrn(_SpecificUrn):
 
     @property
     def id(self) -> str:
-        return self.entity_ids[0]
+        return self._entity_ids[0]
 
 if TYPE_CHECKING:
     from datahub.metadata.schema_classes import DataHubAccessTokenKeyClass
 
 class DataHubAccessTokenUrn(_SpecificUrn):
-    ENTITY_TYPE: ClassVar[str] = "dataHubAccessToken"
-    URN_PARTS: ClassVar[int] = 1
+    ENTITY_TYPE: ClassVar[Literal["dataHubAccessToken"]] = "dataHubAccessToken"
+    _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["DataHubAccessTokenUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            id = UrnEncoder.encode_string(id)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = DataHubAccessTokenUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a DataHubAccessTokenUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not id:
             raise InvalidUrnError("DataHubAccessTokenUrn id cannot be empty")
+        if isinstance(id, DataHubAccessTokenUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a DataHubAccessTokenUrn but got {id}')
         if UrnEncoder.contains_reserved_char(id):
             raise InvalidUrnError(f'DataHubAccessTokenUrn id contains reserved characters')
 
@@ -1686,8 +2031,8 @@ class DataHubAccessTokenUrn(_SpecificUrn):
 
     @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}")
+        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
@@ -1707,23 +2052,34 @@ class DataHubAccessTokenUrn(_SpecificUrn):
 
     @property
     def id(self) -> str:
-        return self.entity_ids[0]
+        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
+    ENTITY_TYPE: ClassVar[Literal["dataHubAction"]] = "dataHubAction"
+    _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["DataHubActionUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            id = UrnEncoder.encode_string(id)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = DataHubActionUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a DataHubActionUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not id:
             raise InvalidUrnError("DataHubActionUrn id cannot be empty")
+        if isinstance(id, DataHubActionUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a DataHubActionUrn but got {id}')
         if UrnEncoder.contains_reserved_char(id):
             raise InvalidUrnError(f'DataHubActionUrn id contains reserved characters')
 
@@ -1731,8 +2087,8 @@ class DataHubActionUrn(_SpecificUrn):
 
     @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}")
+        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
@@ -1752,25 +2108,34 @@ class DataHubActionUrn(_SpecificUrn):
 
     @property
     def id(self) -> str:
-        return self.entity_ids[0]
+        return self._entity_ids[0]
 
 if TYPE_CHECKING:
     from datahub.metadata.schema_classes import DataPlatformKeyClass
 
 class DataPlatformUrn(_SpecificUrn):
-    ENTITY_TYPE: ClassVar[str] = "dataPlatform"
-    URN_PARTS: ClassVar[int] = 1
+    ENTITY_TYPE: ClassVar[Literal["dataPlatform"]] = "dataPlatform"
+    _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, platform_name: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, platform_name: Union["DataPlatformUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            if platform_name.startswith("urn:li:dataPlatform:"):
-                platform_name = DataPlatformUrn.from_string(platform_name).platform_name
-            platform_name = UrnEncoder.encode_string(platform_name)
+            if isinstance(platform_name, str):
+                if platform_name.startswith('urn:li:'):
+                    try:
+                        platform_name = DataPlatformUrn.from_string(platform_name)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a DataPlatformUrn but got {platform_name}')
+                else:
+                    platform_name = UrnEncoder.encode_string(platform_name)
 
         # Validation logic.
         if not platform_name:
             raise InvalidUrnError("DataPlatformUrn platform_name cannot be empty")
+        if isinstance(platform_name, DataPlatformUrn):
+            platform_name = platform_name.platform_name
+        elif isinstance(platform_name, Urn):
+            raise InvalidUrnError(f'Expecting a DataPlatformUrn but got {platform_name}')
         if UrnEncoder.contains_reserved_char(platform_name):
             raise InvalidUrnError(f'DataPlatformUrn platform_name contains reserved characters')
 
@@ -1778,8 +2143,8 @@ class DataPlatformUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "DataPlatformUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"DataPlatformUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"DataPlatformUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(platform_name=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -1804,23 +2169,34 @@ class DataPlatformUrn(_SpecificUrn):
 
     @property
     def platform_name(self) -> str:
-        return self.entity_ids[0]
+        return self._entity_ids[0]
 
 if TYPE_CHECKING:
     from datahub.metadata.schema_classes import ContainerKeyClass
 
 class ContainerUrn(_SpecificUrn):
-    ENTITY_TYPE: ClassVar[str] = "container"
-    URN_PARTS: ClassVar[int] = 1
+    ENTITY_TYPE: ClassVar[Literal["container"]] = "container"
+    _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, guid: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, guid: Union["ContainerUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            guid = UrnEncoder.encode_string(guid)
+            if isinstance(guid, str):
+                if guid.startswith('urn:li:'):
+                    try:
+                        guid = ContainerUrn.from_string(guid)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a ContainerUrn but got {guid}')
+                else:
+                    guid = UrnEncoder.encode_string(guid)
 
         # Validation logic.
         if not guid:
             raise InvalidUrnError("ContainerUrn guid cannot be empty")
+        if isinstance(guid, ContainerUrn):
+            guid = guid.guid
+        elif isinstance(guid, Urn):
+            raise InvalidUrnError(f'Expecting a ContainerUrn but got {guid}')
         if UrnEncoder.contains_reserved_char(guid):
             raise InvalidUrnError(f'ContainerUrn guid contains reserved characters')
 
@@ -1828,8 +2204,8 @@ class ContainerUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "ContainerUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"ContainerUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"ContainerUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(guid=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -1849,23 +2225,34 @@ class ContainerUrn(_SpecificUrn):
 
     @property
     def guid(self) -> str:
-        return self.entity_ids[0]
+        return self._entity_ids[0]
 
 if TYPE_CHECKING:
     from datahub.metadata.schema_classes import TagKeyClass
 
 class TagUrn(_SpecificUrn):
-    ENTITY_TYPE: ClassVar[str] = "tag"
-    URN_PARTS: ClassVar[int] = 1
+    ENTITY_TYPE: ClassVar[Literal["tag"]] = "tag"
+    _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, name: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, name: Union["TagUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            name = UrnEncoder.encode_string(name)
+            if isinstance(name, str):
+                if name.startswith('urn:li:'):
+                    try:
+                        name = TagUrn.from_string(name)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a TagUrn but got {name}')
+                else:
+                    name = UrnEncoder.encode_string(name)
 
         # Validation logic.
         if not name:
             raise InvalidUrnError("TagUrn name cannot be empty")
+        if isinstance(name, TagUrn):
+            name = name.name
+        elif isinstance(name, Urn):
+            raise InvalidUrnError(f'Expecting a TagUrn but got {name}')
         if UrnEncoder.contains_reserved_char(name):
             raise InvalidUrnError(f'TagUrn name contains reserved characters')
 
@@ -1873,8 +2260,8 @@ class TagUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "TagUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"TagUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"TagUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(name=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -1899,23 +2286,34 @@ class TagUrn(_SpecificUrn):
 
     @property
     def name(self) -> str:
-        return self.entity_ids[0]
+        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
+    ENTITY_TYPE: ClassVar[Literal["dataHubPolicy"]] = "dataHubPolicy"
+    _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["DataHubPolicyUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            id = UrnEncoder.encode_string(id)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = DataHubPolicyUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a DataHubPolicyUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not id:
             raise InvalidUrnError("DataHubPolicyUrn id cannot be empty")
+        if isinstance(id, DataHubPolicyUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a DataHubPolicyUrn but got {id}')
         if UrnEncoder.contains_reserved_char(id):
             raise InvalidUrnError(f'DataHubPolicyUrn id contains reserved characters')
 
@@ -1923,8 +2321,8 @@ class DataHubPolicyUrn(_SpecificUrn):
 
     @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}")
+        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
@@ -1944,23 +2342,34 @@ class DataHubPolicyUrn(_SpecificUrn):
 
     @property
     def id(self) -> str:
-        return self.entity_ids[0]
+        return self._entity_ids[0]
 
 if TYPE_CHECKING:
     from datahub.metadata.schema_classes import ConstraintKeyClass
 
 class ConstraintUrn(_SpecificUrn):
-    ENTITY_TYPE: ClassVar[str] = "constraint"
-    URN_PARTS: ClassVar[int] = 1
+    ENTITY_TYPE: ClassVar[Literal["constraint"]] = "constraint"
+    _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["ConstraintUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            id = UrnEncoder.encode_string(id)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = ConstraintUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a ConstraintUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not id:
             raise InvalidUrnError("ConstraintUrn id cannot be empty")
+        if isinstance(id, ConstraintUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a ConstraintUrn but got {id}')
         if UrnEncoder.contains_reserved_char(id):
             raise InvalidUrnError(f'ConstraintUrn id contains reserved characters')
 
@@ -1968,8 +2377,8 @@ class ConstraintUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "ConstraintUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"ConstraintUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"ConstraintUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(id=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -1989,23 +2398,34 @@ class ConstraintUrn(_SpecificUrn):
 
     @property
     def id(self) -> str:
-        return self.entity_ids[0]
+        return self._entity_ids[0]
 
 if TYPE_CHECKING:
     from datahub.metadata.schema_classes import GlossaryNodeKeyClass
 
 class GlossaryNodeUrn(_SpecificUrn):
-    ENTITY_TYPE: ClassVar[str] = "glossaryNode"
-    URN_PARTS: ClassVar[int] = 1
+    ENTITY_TYPE: ClassVar[Literal["glossaryNode"]] = "glossaryNode"
+    _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, name: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, name: Union["GlossaryNodeUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            name = UrnEncoder.encode_string(name)
+            if isinstance(name, str):
+                if name.startswith('urn:li:'):
+                    try:
+                        name = GlossaryNodeUrn.from_string(name)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a GlossaryNodeUrn but got {name}')
+                else:
+                    name = UrnEncoder.encode_string(name)
 
         # Validation logic.
         if not name:
             raise InvalidUrnError("GlossaryNodeUrn name cannot be empty")
+        if isinstance(name, GlossaryNodeUrn):
+            name = name.name
+        elif isinstance(name, Urn):
+            raise InvalidUrnError(f'Expecting a GlossaryNodeUrn but got {name}')
         if UrnEncoder.contains_reserved_char(name):
             raise InvalidUrnError(f'GlossaryNodeUrn name contains reserved characters')
 
@@ -2013,8 +2433,8 @@ class GlossaryNodeUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "GlossaryNodeUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"GlossaryNodeUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"GlossaryNodeUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(name=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -2034,14 +2454,14 @@ class GlossaryNodeUrn(_SpecificUrn):
 
     @property
     def name(self) -> str:
-        return self.entity_ids[0]
+        return self._entity_ids[0]
 
 if TYPE_CHECKING:
     from datahub.metadata.schema_classes import DataProcessKeyClass
 
 class DataProcessUrn(_SpecificUrn):
-    ENTITY_TYPE: ClassVar[str] = "dataProcess"
-    URN_PARTS: ClassVar[int] = 3
+    ENTITY_TYPE: ClassVar[Literal["dataProcess"]] = "dataProcess"
+    _URN_PARTS: ClassVar[int] = 3
 
     def __init__(self, name: str, orchestrator: str, env: str = "PROD", *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
@@ -2049,7 +2469,6 @@ class DataProcessUrn(_SpecificUrn):
             name = UrnEncoder.encode_string(name)
             orchestrator = UrnEncoder.encode_string(orchestrator)
             env = env.upper()
-            env = UrnEncoder.encode_string(env)
 
         # Validation logic.
         if not name:
@@ -2069,8 +2488,8 @@ class DataProcessUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "DataProcessUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"DataProcessUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"DataProcessUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(name=entity_ids[0], orchestrator=entity_ids[1], env=entity_ids[2], _allow_coercion=False)
 
     @classmethod
@@ -2090,31 +2509,42 @@ class DataProcessUrn(_SpecificUrn):
 
     @property
     def name(self) -> str:
-        return self.entity_ids[0]
+        return self._entity_ids[0]
 
     @property
     def orchestrator(self) -> str:
-        return self.entity_ids[1]
+        return self._entity_ids[1]
 
     @property
     def env(self) -> str:
-        return self.entity_ids[2]
+        return self._entity_ids[2]
 
 if TYPE_CHECKING:
     from datahub.metadata.schema_classes import DataHubStepStateKeyClass
 
 class DataHubStepStateUrn(_SpecificUrn):
-    ENTITY_TYPE: ClassVar[str] = "dataHubStepState"
-    URN_PARTS: ClassVar[int] = 1
+    ENTITY_TYPE: ClassVar[Literal["dataHubStepState"]] = "dataHubStepState"
+    _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["DataHubStepStateUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            id = UrnEncoder.encode_string(id)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = DataHubStepStateUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a DataHubStepStateUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not id:
             raise InvalidUrnError("DataHubStepStateUrn id cannot be empty")
+        if isinstance(id, DataHubStepStateUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a DataHubStepStateUrn but got {id}')
         if UrnEncoder.contains_reserved_char(id):
             raise InvalidUrnError(f'DataHubStepStateUrn id contains reserved characters')
 
@@ -2122,8 +2552,8 @@ class DataHubStepStateUrn(_SpecificUrn):
 
     @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}")
+        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
@@ -2143,14 +2573,14 @@ class DataHubStepStateUrn(_SpecificUrn):
 
     @property
     def id(self) -> str:
-        return self.entity_ids[0]
+        return self._entity_ids[0]
 
 if TYPE_CHECKING:
     from datahub.metadata.schema_classes import NotebookKeyClass
 
 class NotebookUrn(_SpecificUrn):
-    ENTITY_TYPE: ClassVar[str] = "notebook"
-    URN_PARTS: ClassVar[int] = 2
+    ENTITY_TYPE: ClassVar[Literal["notebook"]] = "notebook"
+    _URN_PARTS: ClassVar[int] = 2
 
     def __init__(self, notebook_tool: str, notebook_id: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
@@ -2172,8 +2602,8 @@ class NotebookUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "NotebookUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"NotebookUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"NotebookUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(notebook_tool=entity_ids[0], notebook_id=entity_ids[1], _allow_coercion=False)
 
     @classmethod
@@ -2201,18 +2631,18 @@ class NotebookUrn(_SpecificUrn):
 
     @property
     def notebook_tool(self) -> str:
-        return self.entity_ids[0]
+        return self._entity_ids[0]
 
     @property
     def notebook_id(self) -> str:
-        return self.entity_ids[1]
+        return self._entity_ids[1]
 
 if TYPE_CHECKING:
     from datahub.metadata.schema_classes import MLFeatureKeyClass
 
 class MlFeatureUrn(_SpecificUrn):
-    ENTITY_TYPE: ClassVar[str] = "mlFeature"
-    URN_PARTS: ClassVar[int] = 2
+    ENTITY_TYPE: ClassVar[Literal["mlFeature"]] = "mlFeature"
+    _URN_PARTS: ClassVar[int] = 2
 
     def __init__(self, feature_namespace: str, name: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
@@ -2234,8 +2664,8 @@ class MlFeatureUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "MlFeatureUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"MlFeatureUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"MlFeatureUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(feature_namespace=entity_ids[0], name=entity_ids[1], _allow_coercion=False)
 
     @classmethod
@@ -2255,27 +2685,38 @@ class MlFeatureUrn(_SpecificUrn):
 
     @property
     def feature_namespace(self) -> str:
-        return self.entity_ids[0]
+        return self._entity_ids[0]
 
     @property
     def name(self) -> str:
-        return self.entity_ids[1]
+        return self._entity_ids[1]
 
 if TYPE_CHECKING:
     from datahub.metadata.schema_classes import DataHubUpgradeKeyClass
 
 class DataHubUpgradeUrn(_SpecificUrn):
-    ENTITY_TYPE: ClassVar[str] = "dataHubUpgrade"
-    URN_PARTS: ClassVar[int] = 1
+    ENTITY_TYPE: ClassVar[Literal["dataHubUpgrade"]] = "dataHubUpgrade"
+    _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["DataHubUpgradeUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            id = UrnEncoder.encode_string(id)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = DataHubUpgradeUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a DataHubUpgradeUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not id:
             raise InvalidUrnError("DataHubUpgradeUrn id cannot be empty")
+        if isinstance(id, DataHubUpgradeUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a DataHubUpgradeUrn but got {id}')
         if UrnEncoder.contains_reserved_char(id):
             raise InvalidUrnError(f'DataHubUpgradeUrn id contains reserved characters')
 
@@ -2283,8 +2724,8 @@ class DataHubUpgradeUrn(_SpecificUrn):
 
     @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}")
+        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
@@ -2304,14 +2745,14 @@ class DataHubUpgradeUrn(_SpecificUrn):
 
     @property
     def id(self) -> str:
-        return self.entity_ids[0]
+        return self._entity_ids[0]
 
 if TYPE_CHECKING:
     from datahub.metadata.schema_classes import DashboardKeyClass
 
 class DashboardUrn(_SpecificUrn):
-    ENTITY_TYPE: ClassVar[str] = "dashboard"
-    URN_PARTS: ClassVar[int] = 2
+    ENTITY_TYPE: ClassVar[Literal["dashboard"]] = "dashboard"
+    _URN_PARTS: ClassVar[int] = 2
 
     def __init__(self, dashboard_tool: str, dashboard_id: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
@@ -2333,8 +2774,8 @@ class DashboardUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "DashboardUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"DashboardUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"DashboardUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(dashboard_tool=entity_ids[0], dashboard_id=entity_ids[1], _allow_coercion=False)
 
     @classmethod
@@ -2354,31 +2795,30 @@ class DashboardUrn(_SpecificUrn):
 
     @property
     def dashboard_tool(self) -> str:
-        return self.entity_ids[0]
+        return self._entity_ids[0]
 
     @property
     def dashboard_id(self) -> str:
-        return self.entity_ids[1]
+        return self._entity_ids[1]
 
 if TYPE_CHECKING:
     from datahub.metadata.schema_classes import MLModelKeyClass
 
 class MlModelUrn(_SpecificUrn):
-    ENTITY_TYPE: ClassVar[str] = "mlModel"
-    URN_PARTS: ClassVar[int] = 3
+    ENTITY_TYPE: ClassVar[Literal["mlModel"]] = "mlModel"
+    _URN_PARTS: ClassVar[int] = 3
 
-    def __init__(self, platform: str, name: str, env: str = "PROD", *, _allow_coercion: bool = True) -> None:
+    def __init__(self, platform: Union["DataPlatformUrn", str], name: str, env: str = "PROD", *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
             platform = DataPlatformUrn(platform).urn()
             name = UrnEncoder.encode_string(name)
             env = env.upper()
-            env = UrnEncoder.encode_string(env)
 
         # Validation logic.
         if not platform:
             raise InvalidUrnError("MlModelUrn platform cannot be empty")
-        platform = str(platform)
+        platform = str(platform)  # convert urn type to str
         assert DataPlatformUrn.from_string(platform)
         if not name:
             raise InvalidUrnError("MlModelUrn name cannot be empty")
@@ -2393,8 +2833,8 @@ class MlModelUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "MlModelUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"MlModelUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"MlModelUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(platform=entity_ids[0], name=entity_ids[1], env=entity_ids[2], _allow_coercion=False)
 
     @classmethod
@@ -2414,31 +2854,42 @@ class MlModelUrn(_SpecificUrn):
 
     @property
     def platform(self) -> str:
-        return self.entity_ids[0]
+        return self._entity_ids[0]
 
     @property
     def name(self) -> str:
-        return self.entity_ids[1]
+        return self._entity_ids[1]
 
     @property
     def env(self) -> str:
-        return self.entity_ids[2]
+        return self._entity_ids[2]
 
 if TYPE_CHECKING:
     from datahub.metadata.schema_classes import IncidentKeyClass
 
 class IncidentUrn(_SpecificUrn):
-    ENTITY_TYPE: ClassVar[str] = "incident"
-    URN_PARTS: ClassVar[int] = 1
+    ENTITY_TYPE: ClassVar[Literal["incident"]] = "incident"
+    _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["IncidentUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            id = UrnEncoder.encode_string(id)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = IncidentUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a IncidentUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not id:
             raise InvalidUrnError("IncidentUrn id cannot be empty")
+        if isinstance(id, IncidentUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a IncidentUrn but got {id}')
         if UrnEncoder.contains_reserved_char(id):
             raise InvalidUrnError(f'IncidentUrn id contains reserved characters')
 
@@ -2446,8 +2897,8 @@ class IncidentUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "IncidentUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"IncidentUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"IncidentUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(id=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -2467,23 +2918,34 @@ class IncidentUrn(_SpecificUrn):
 
     @property
     def id(self) -> str:
-        return self.entity_ids[0]
+        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
+    ENTITY_TYPE: ClassVar[Literal["globalSettings"]] = "globalSettings"
+    _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["GlobalSettingsUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            id = UrnEncoder.encode_string(id)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = GlobalSettingsUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a GlobalSettingsUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not id:
             raise InvalidUrnError("GlobalSettingsUrn id cannot be empty")
+        if isinstance(id, GlobalSettingsUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a GlobalSettingsUrn but got {id}')
         if UrnEncoder.contains_reserved_char(id):
             raise InvalidUrnError(f'GlobalSettingsUrn id contains reserved characters')
 
@@ -2491,8 +2953,8 @@ class GlobalSettingsUrn(_SpecificUrn):
 
     @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}")
+        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
@@ -2512,23 +2974,34 @@ class GlobalSettingsUrn(_SpecificUrn):
 
     @property
     def id(self) -> str:
-        return self.entity_ids[0]
+        return self._entity_ids[0]
 
 if TYPE_CHECKING:
     from datahub.metadata.schema_classes import DataHubViewKeyClass
 
 class DataHubViewUrn(_SpecificUrn):
-    ENTITY_TYPE: ClassVar[str] = "dataHubView"
-    URN_PARTS: ClassVar[int] = 1
+    ENTITY_TYPE: ClassVar[Literal["dataHubView"]] = "dataHubView"
+    _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["DataHubViewUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            id = UrnEncoder.encode_string(id)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = DataHubViewUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a DataHubViewUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not id:
             raise InvalidUrnError("DataHubViewUrn id cannot be empty")
+        if isinstance(id, DataHubViewUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a DataHubViewUrn but got {id}')
         if UrnEncoder.contains_reserved_char(id):
             raise InvalidUrnError(f'DataHubViewUrn id contains reserved characters')
 
@@ -2536,8 +3009,8 @@ class DataHubViewUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "DataHubViewUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"DataHubViewUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"DataHubViewUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(id=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -2557,14 +3030,14 @@ class DataHubViewUrn(_SpecificUrn):
 
     @property
     def id(self) -> str:
-        return self.entity_ids[0]
+        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
+    ENTITY_TYPE: ClassVar[Literal["dataHubRetention"]] = "dataHubRetention"
+    _URN_PARTS: ClassVar[int] = 2
 
     def __init__(self, entity_name: str, aspect_name: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
@@ -2586,8 +3059,8 @@ class DataHubRetentionUrn(_SpecificUrn):
 
     @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}")
+        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
@@ -2607,27 +3080,38 @@ class DataHubRetentionUrn(_SpecificUrn):
 
     @property
     def entity_name(self) -> str:
-        return self.entity_ids[0]
+        return self._entity_ids[0]
 
     @property
     def aspect_name(self) -> str:
-        return self.entity_ids[1]
+        return self._entity_ids[1]
 
 if TYPE_CHECKING:
     from datahub.metadata.schema_classes import OwnershipTypeKeyClass
 
 class OwnershipTypeUrn(_SpecificUrn):
-    ENTITY_TYPE: ClassVar[str] = "ownershipType"
-    URN_PARTS: ClassVar[int] = 1
+    ENTITY_TYPE: ClassVar[Literal["ownershipType"]] = "ownershipType"
+    _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["OwnershipTypeUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            id = UrnEncoder.encode_string(id)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = OwnershipTypeUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a OwnershipTypeUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not id:
             raise InvalidUrnError("OwnershipTypeUrn id cannot be empty")
+        if isinstance(id, OwnershipTypeUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a OwnershipTypeUrn but got {id}')
         if UrnEncoder.contains_reserved_char(id):
             raise InvalidUrnError(f'OwnershipTypeUrn id contains reserved characters')
 
@@ -2635,8 +3119,8 @@ class OwnershipTypeUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "OwnershipTypeUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"OwnershipTypeUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"OwnershipTypeUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(id=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -2656,23 +3140,34 @@ class OwnershipTypeUrn(_SpecificUrn):
 
     @property
     def id(self) -> str:
-        return self.entity_ids[0]
+        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
+    ENTITY_TYPE: ClassVar[Literal["actionRequest"]] = "actionRequest"
+    _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["ActionRequestUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            id = UrnEncoder.encode_string(id)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = ActionRequestUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a ActionRequestUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not id:
             raise InvalidUrnError("ActionRequestUrn id cannot be empty")
+        if isinstance(id, ActionRequestUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a ActionRequestUrn but got {id}')
         if UrnEncoder.contains_reserved_char(id):
             raise InvalidUrnError(f'ActionRequestUrn id contains reserved characters')
 
@@ -2680,8 +3175,8 @@ class ActionRequestUrn(_SpecificUrn):
 
     @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}")
+        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
@@ -2701,14 +3196,70 @@ class ActionRequestUrn(_SpecificUrn):
 
     @property
     def id(self) -> str:
-        return self.entity_ids[0]
+        return self._entity_ids[0]
+
+if TYPE_CHECKING:
+    from datahub.metadata.schema_classes import RemoteExecutorGlobalConfigKeyClass
+
+class DataHubRemoteExecutorGlobalConfigUrn(_SpecificUrn):
+    ENTITY_TYPE: ClassVar[Literal["dataHubRemoteExecutorGlobalConfig"]] = "dataHubRemoteExecutorGlobalConfig"
+    _URN_PARTS: ClassVar[int] = 1
+
+    def __init__(self, id: Union["DataHubRemoteExecutorGlobalConfigUrn", str], *, _allow_coercion: bool = True) -> None:
+        if _allow_coercion:
+            # Field coercion logic (if any is required).
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = DataHubRemoteExecutorGlobalConfigUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a DataHubRemoteExecutorGlobalConfigUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
+
+        # Validation logic.
+        if not id:
+            raise InvalidUrnError("DataHubRemoteExecutorGlobalConfigUrn id cannot be empty")
+        if isinstance(id, DataHubRemoteExecutorGlobalConfigUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a DataHubRemoteExecutorGlobalConfigUrn but got {id}')
+        if UrnEncoder.contains_reserved_char(id):
+            raise InvalidUrnError(f'DataHubRemoteExecutorGlobalConfigUrn id contains reserved characters')
+
+        super().__init__(self.ENTITY_TYPE, [id])
+
+    @classmethod
+    def _parse_ids(cls, entity_ids: List[str]) -> "DataHubRemoteExecutorGlobalConfigUrn":
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"DataHubRemoteExecutorGlobalConfigUrn 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["RemoteExecutorGlobalConfigKeyClass"]:
+        from datahub.metadata.schema_classes import RemoteExecutorGlobalConfigKeyClass
+
+        return RemoteExecutorGlobalConfigKeyClass
+
+    def to_key_aspect(self) -> "RemoteExecutorGlobalConfigKeyClass":
+        from datahub.metadata.schema_classes import RemoteExecutorGlobalConfigKeyClass
+
+        return RemoteExecutorGlobalConfigKeyClass(id=self.id)
+
+    @classmethod
+    def from_key_aspect(cls, key_aspect: "RemoteExecutorGlobalConfigKeyClass") -> "DataHubRemoteExecutorGlobalConfigUrn":
+        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 DataFlowKeyClass
 
 class DataFlowUrn(_SpecificUrn):
-    ENTITY_TYPE: ClassVar[str] = "dataFlow"
-    URN_PARTS: ClassVar[int] = 3
+    ENTITY_TYPE: ClassVar[Literal["dataFlow"]] = "dataFlow"
+    _URN_PARTS: ClassVar[int] = 3
 
     def __init__(self, orchestrator: str, flow_id: str, cluster: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
@@ -2735,8 +3286,8 @@ class DataFlowUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "DataFlowUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"DataFlowUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"DataFlowUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(orchestrator=entity_ids[0], flow_id=entity_ids[1], cluster=entity_ids[2], _allow_coercion=False)
 
     @classmethod
@@ -2782,31 +3333,42 @@ class DataFlowUrn(_SpecificUrn):
 
     @property
     def orchestrator(self) -> str:
-        return self.entity_ids[0]
+        return self._entity_ids[0]
 
     @property
     def flow_id(self) -> str:
-        return self.entity_ids[1]
+        return self._entity_ids[1]
 
     @property
     def cluster(self) -> str:
-        return self.entity_ids[2]
+        return self._entity_ids[2]
 
 if TYPE_CHECKING:
     from datahub.metadata.schema_classes import DataContractKeyClass
 
 class DataContractUrn(_SpecificUrn):
-    ENTITY_TYPE: ClassVar[str] = "dataContract"
-    URN_PARTS: ClassVar[int] = 1
+    ENTITY_TYPE: ClassVar[Literal["dataContract"]] = "dataContract"
+    _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["DataContractUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            id = UrnEncoder.encode_string(id)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = DataContractUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a DataContractUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not id:
             raise InvalidUrnError("DataContractUrn id cannot be empty")
+        if isinstance(id, DataContractUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a DataContractUrn but got {id}')
         if UrnEncoder.contains_reserved_char(id):
             raise InvalidUrnError(f'DataContractUrn id contains reserved characters')
 
@@ -2814,8 +3376,8 @@ class DataContractUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "DataContractUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"DataContractUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"DataContractUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(id=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -2835,23 +3397,34 @@ class DataContractUrn(_SpecificUrn):
 
     @property
     def id(self) -> str:
-        return self.entity_ids[0]
+        return self._entity_ids[0]
 
 if TYPE_CHECKING:
     from datahub.metadata.schema_classes import DataHubConnectionKeyClass
 
 class DataHubConnectionUrn(_SpecificUrn):
-    ENTITY_TYPE: ClassVar[str] = "dataHubConnection"
-    URN_PARTS: ClassVar[int] = 1
+    ENTITY_TYPE: ClassVar[Literal["dataHubConnection"]] = "dataHubConnection"
+    _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["DataHubConnectionUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            id = UrnEncoder.encode_string(id)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = DataHubConnectionUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a DataHubConnectionUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not id:
             raise InvalidUrnError("DataHubConnectionUrn id cannot be empty")
+        if isinstance(id, DataHubConnectionUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a DataHubConnectionUrn but got {id}')
         if UrnEncoder.contains_reserved_char(id):
             raise InvalidUrnError(f'DataHubConnectionUrn id contains reserved characters')
 
@@ -2859,8 +3432,8 @@ class DataHubConnectionUrn(_SpecificUrn):
 
     @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}")
+        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
@@ -2880,23 +3453,34 @@ class DataHubConnectionUrn(_SpecificUrn):
 
     @property
     def id(self) -> str:
-        return self.entity_ids[0]
+        return self._entity_ids[0]
 
 if TYPE_CHECKING:
     from datahub.metadata.schema_classes import RemoteExecutorKeyClass
 
 class DataHubRemoteExecutorUrn(_SpecificUrn):
-    ENTITY_TYPE: ClassVar[str] = "dataHubRemoteExecutor"
-    URN_PARTS: ClassVar[int] = 1
+    ENTITY_TYPE: ClassVar[Literal["dataHubRemoteExecutor"]] = "dataHubRemoteExecutor"
+    _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["DataHubRemoteExecutorUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            id = UrnEncoder.encode_string(id)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = DataHubRemoteExecutorUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a DataHubRemoteExecutorUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not id:
             raise InvalidUrnError("DataHubRemoteExecutorUrn id cannot be empty")
+        if isinstance(id, DataHubRemoteExecutorUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a DataHubRemoteExecutorUrn but got {id}')
         if UrnEncoder.contains_reserved_char(id):
             raise InvalidUrnError(f'DataHubRemoteExecutorUrn id contains reserved characters')
 
@@ -2904,8 +3488,8 @@ class DataHubRemoteExecutorUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "DataHubRemoteExecutorUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"DataHubRemoteExecutorUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"DataHubRemoteExecutorUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(id=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -2925,24 +3509,32 @@ class DataHubRemoteExecutorUrn(_SpecificUrn):
 
     @property
     def id(self) -> str:
-        return self.entity_ids[0]
+        return self._entity_ids[0]
 
 if TYPE_CHECKING:
     from datahub.metadata.schema_classes import MonitorKeyClass
 
 class MonitorUrn(_SpecificUrn):
-    ENTITY_TYPE: ClassVar[str] = "monitor"
-    URN_PARTS: ClassVar[int] = 2
+    ENTITY_TYPE: ClassVar[Literal["monitor"]] = "monitor"
+    _URN_PARTS: ClassVar[int] = 2
 
-    def __init__(self, entity: str, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, entity: Union["DatasetUrn", str], id: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
+            if isinstance(entity, str):
+                if entity.startswith('urn:li:'):
+                    try:
+                        entity = DatasetUrn.from_string(entity)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a DatasetUrn but got {entity}')
+                else:
+                    entity = UrnEncoder.encode_string(entity)
             id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not entity:
             raise InvalidUrnError("MonitorUrn entity cannot be empty")
-        entity = str(entity)
+        entity = str(entity)  # convert urn type to str
         assert DatasetUrn.from_string(entity)
         if not id:
             raise InvalidUrnError("MonitorUrn id cannot be empty")
@@ -2953,8 +3545,8 @@ class MonitorUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "MonitorUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"MonitorUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"MonitorUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(entity=entity_ids[0], id=entity_ids[1], _allow_coercion=False)
 
     @classmethod
@@ -2974,27 +3566,38 @@ class MonitorUrn(_SpecificUrn):
 
     @property
     def entity(self) -> str:
-        return self.entity_ids[0]
+        return self._entity_ids[0]
 
     @property
     def id(self) -> str:
-        return self.entity_ids[1]
+        return self._entity_ids[1]
 
 if TYPE_CHECKING:
     from datahub.metadata.schema_classes import CorpUserKeyClass
 
 class CorpUserUrn(_SpecificUrn):
-    ENTITY_TYPE: ClassVar[str] = "corpuser"
-    URN_PARTS: ClassVar[int] = 1
+    ENTITY_TYPE: ClassVar[Literal["corpuser"]] = "corpuser"
+    _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, username: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, username: Union["CorpUserUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            username = UrnEncoder.encode_string(username)
+            if isinstance(username, str):
+                if username.startswith('urn:li:'):
+                    try:
+                        username = CorpUserUrn.from_string(username)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a CorpUserUrn but got {username}')
+                else:
+                    username = UrnEncoder.encode_string(username)
 
         # Validation logic.
         if not username:
             raise InvalidUrnError("CorpUserUrn username cannot be empty")
+        if isinstance(username, CorpUserUrn):
+            username = username.username
+        elif isinstance(username, Urn):
+            raise InvalidUrnError(f'Expecting a CorpUserUrn but got {username}')
         if UrnEncoder.contains_reserved_char(username):
             raise InvalidUrnError(f'CorpUserUrn username contains reserved characters')
 
@@ -3002,8 +3605,8 @@ class CorpUserUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "CorpUserUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"CorpUserUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"CorpUserUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(username=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -3028,14 +3631,14 @@ class CorpUserUrn(_SpecificUrn):
 
     @property
     def username(self) -> str:
-        return self.entity_ids[0]
+        return self._entity_ids[0]
 
 if TYPE_CHECKING:
     from datahub.metadata.schema_classes import VersionSetKeyClass
 
 class VersionSetUrn(_SpecificUrn):
-    ENTITY_TYPE: ClassVar[str] = "versionSet"
-    URN_PARTS: ClassVar[int] = 2
+    ENTITY_TYPE: ClassVar[Literal["versionSet"]] = "versionSet"
+    _URN_PARTS: ClassVar[int] = 2
 
     def __init__(self, id: str, entity_type: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
@@ -3057,8 +3660,8 @@ class VersionSetUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "VersionSetUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"VersionSetUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"VersionSetUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(id=entity_ids[0], entity_type=entity_ids[1], _allow_coercion=False)
 
     @classmethod
@@ -3078,27 +3681,38 @@ class VersionSetUrn(_SpecificUrn):
 
     @property
     def id(self) -> str:
-        return self.entity_ids[0]
+        return self._entity_ids[0]
 
     @property
     def entity_type(self) -> str:
-        return self.entity_ids[1]
+        return self._entity_ids[1]
 
 if TYPE_CHECKING:
     from datahub.metadata.schema_classes import TestKeyClass
 
 class TestUrn(_SpecificUrn):
-    ENTITY_TYPE: ClassVar[str] = "test"
-    URN_PARTS: ClassVar[int] = 1
+    ENTITY_TYPE: ClassVar[Literal["test"]] = "test"
+    _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["TestUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            id = UrnEncoder.encode_string(id)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = TestUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a TestUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not id:
             raise InvalidUrnError("TestUrn id cannot be empty")
+        if isinstance(id, TestUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a TestUrn but got {id}')
         if UrnEncoder.contains_reserved_char(id):
             raise InvalidUrnError(f'TestUrn id contains reserved characters')
 
@@ -3106,8 +3720,8 @@ class TestUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "TestUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"TestUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"TestUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(id=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -3127,23 +3741,34 @@ class TestUrn(_SpecificUrn):
 
     @property
     def id(self) -> str:
-        return self.entity_ids[0]
+        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
+    ENTITY_TYPE: ClassVar[Literal["dataHubIngestionSource"]] = "dataHubIngestionSource"
+    _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["DataHubIngestionSourceUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            id = UrnEncoder.encode_string(id)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = DataHubIngestionSourceUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a DataHubIngestionSourceUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not id:
             raise InvalidUrnError("DataHubIngestionSourceUrn id cannot be empty")
+        if isinstance(id, DataHubIngestionSourceUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a DataHubIngestionSourceUrn but got {id}')
         if UrnEncoder.contains_reserved_char(id):
             raise InvalidUrnError(f'DataHubIngestionSourceUrn id contains reserved characters')
 
@@ -3151,8 +3776,8 @@ class DataHubIngestionSourceUrn(_SpecificUrn):
 
     @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}")
+        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
@@ -3172,27 +3797,26 @@ class DataHubIngestionSourceUrn(_SpecificUrn):
 
     @property
     def id(self) -> str:
-        return self.entity_ids[0]
+        return self._entity_ids[0]
 
 if TYPE_CHECKING:
     from datahub.metadata.schema_classes import MLModelDeploymentKeyClass
 
 class MlModelDeploymentUrn(_SpecificUrn):
-    ENTITY_TYPE: ClassVar[str] = "mlModelDeployment"
-    URN_PARTS: ClassVar[int] = 3
+    ENTITY_TYPE: ClassVar[Literal["mlModelDeployment"]] = "mlModelDeployment"
+    _URN_PARTS: ClassVar[int] = 3
 
-    def __init__(self, platform: str, name: str, env: str = "PROD", *, _allow_coercion: bool = True) -> None:
+    def __init__(self, platform: Union["DataPlatformUrn", str], name: str, env: str = "PROD", *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
             platform = DataPlatformUrn(platform).urn()
             name = UrnEncoder.encode_string(name)
             env = env.upper()
-            env = UrnEncoder.encode_string(env)
 
         # Validation logic.
         if not platform:
             raise InvalidUrnError("MlModelDeploymentUrn platform cannot be empty")
-        platform = str(platform)
+        platform = str(platform)  # convert urn type to str
         assert DataPlatformUrn.from_string(platform)
         if not name:
             raise InvalidUrnError("MlModelDeploymentUrn name cannot be empty")
@@ -3207,8 +3831,8 @@ class MlModelDeploymentUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "MlModelDeploymentUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"MlModelDeploymentUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"MlModelDeploymentUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(platform=entity_ids[0], name=entity_ids[1], env=entity_ids[2], _allow_coercion=False)
 
     @classmethod
@@ -3228,31 +3852,42 @@ class MlModelDeploymentUrn(_SpecificUrn):
 
     @property
     def platform(self) -> str:
-        return self.entity_ids[0]
+        return self._entity_ids[0]
 
     @property
     def name(self) -> str:
-        return self.entity_ids[1]
+        return self._entity_ids[1]
 
     @property
     def env(self) -> str:
-        return self.entity_ids[2]
+        return self._entity_ids[2]
 
 if TYPE_CHECKING:
     from datahub.metadata.schema_classes import LinkPreviewKeyClass
 
 class LinkPreviewUrn(_SpecificUrn):
-    ENTITY_TYPE: ClassVar[str] = "linkPreview"
-    URN_PARTS: ClassVar[int] = 1
+    ENTITY_TYPE: ClassVar[Literal["linkPreview"]] = "linkPreview"
+    _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["LinkPreviewUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            id = UrnEncoder.encode_string(id)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = LinkPreviewUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a LinkPreviewUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not id:
             raise InvalidUrnError("LinkPreviewUrn id cannot be empty")
+        if isinstance(id, LinkPreviewUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a LinkPreviewUrn but got {id}')
         if UrnEncoder.contains_reserved_char(id):
             raise InvalidUrnError(f'LinkPreviewUrn id contains reserved characters')
 
@@ -3260,8 +3895,8 @@ class LinkPreviewUrn(_SpecificUrn):
 
     @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}")
+        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
@@ -3281,23 +3916,34 @@ class LinkPreviewUrn(_SpecificUrn):
 
     @property
     def id(self) -> str:
-        return self.entity_ids[0]
+        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
+    ENTITY_TYPE: ClassVar[Literal["telemetry"]] = "telemetry"
+    _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, name: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, name: Union["TelemetryUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            name = UrnEncoder.encode_string(name)
+            if isinstance(name, str):
+                if name.startswith('urn:li:'):
+                    try:
+                        name = TelemetryUrn.from_string(name)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a TelemetryUrn but got {name}')
+                else:
+                    name = UrnEncoder.encode_string(name)
 
         # Validation logic.
         if not name:
             raise InvalidUrnError("TelemetryUrn name cannot be empty")
+        if isinstance(name, TelemetryUrn):
+            name = name.name
+        elif isinstance(name, Urn):
+            raise InvalidUrnError(f'Expecting a TelemetryUrn but got {name}')
         if UrnEncoder.contains_reserved_char(name):
             raise InvalidUrnError(f'TelemetryUrn name contains reserved characters')
 
@@ -3305,8 +3951,8 @@ class TelemetryUrn(_SpecificUrn):
 
     @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}")
+        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
@@ -3326,6 +3972,6 @@ class TelemetryUrn(_SpecificUrn):
 
     @property
     def name(self) -> str:
-        return self.entity_ids[0]
+        return self._entity_ids[0]
 
 # fmt: on