twitter-openapi-python-generated 0.0.33__py3-none-any.whl → 0.0.35__py3-none-any.whl

twitter_openapi_python_generated/models/article_cover_media_color_info.py

@@ -23,6 +23,7 @@ from typing import Any, ClassVar, Dict, List
 from twitter_openapi_python_generated.models.article_cover_media_color_info_palette import ArticleCoverMediaColorInfoPalette
 from typing import Optional, Set
 from typing_extensions import Self
+from pydantic_core import to_jsonable_python
 
 class ArticleCoverMediaColorInfo(BaseModel):
     """
@@ -32,7 +33,8 @@ class ArticleCoverMediaColorInfo(BaseModel):
     __properties: ClassVar[List[str]] = ["palette"]
 
     model_config = ConfigDict(
-        populate_by_name=True,
+        validate_by_name=True,
+        validate_by_alias=True,
         validate_assignment=True,
         protected_namespaces=(),
     )
@@ -44,8 +46,7 @@ class ArticleCoverMediaColorInfo(BaseModel):
 
     def to_json(self) -> str:
         """Returns the JSON representation of the model using alias"""
-        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
-        return json.dumps(self.to_dict())
+        return json.dumps(to_jsonable_python(self.to_dict()))
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:
@@ -74,8 +75,7 @@ class ArticleCoverMediaColorInfo(BaseModel):
         _items = []
         if self.palette:
             for _item_palette in self.palette:
-                if _item_palette:
-                    _items.append(_item_palette.to_dict())
+                _items.append(_item_palette.to_dict() if _item_palette is not None else None)
             _dict['palette'] = _items
         return _dict
 

twitter_openapi_python_generated/models/article_cover_media_color_info_palette.py

@@ -23,6 +23,7 @@ from typing import Any, ClassVar, Dict, List, Union
 from twitter_openapi_python_generated.models.article_cover_media_color_info_palette_rgb import ArticleCoverMediaColorInfoPaletteRGB
 from typing import Optional, Set
 from typing_extensions import Self
+from pydantic_core import to_jsonable_python
 
 class ArticleCoverMediaColorInfoPalette(BaseModel):
     """
@@ -33,7 +34,8 @@ class ArticleCoverMediaColorInfoPalette(BaseModel):
     __properties: ClassVar[List[str]] = ["percentage", "rgb"]
 
     model_config = ConfigDict(
-        populate_by_name=True,
+        validate_by_name=True,
+        validate_by_alias=True,
         validate_assignment=True,
         protected_namespaces=(),
     )
@@ -45,8 +47,7 @@ class ArticleCoverMediaColorInfoPalette(BaseModel):
 
     def to_json(self) -> str:
         """Returns the JSON representation of the model using alias"""
-        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
-        return json.dumps(self.to_dict())
+        return json.dumps(to_jsonable_python(self.to_dict()))
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:

twitter_openapi_python_generated/models/article_cover_media_color_info_palette_rgb.py

@@ -22,6 +22,7 @@ from pydantic import BaseModel, ConfigDict, StrictInt
 from typing import Any, ClassVar, Dict, List
 from typing import Optional, Set
 from typing_extensions import Self
+from pydantic_core import to_jsonable_python
 
 class ArticleCoverMediaColorInfoPaletteRGB(BaseModel):
     """
@@ -33,7 +34,8 @@ class ArticleCoverMediaColorInfoPaletteRGB(BaseModel):
     __properties: ClassVar[List[str]] = ["blue", "green", "red"]
 
     model_config = ConfigDict(
-        populate_by_name=True,
+        validate_by_name=True,
+        validate_by_alias=True,
         validate_assignment=True,
         protected_namespaces=(),
     )
@@ -45,8 +47,7 @@ class ArticleCoverMediaColorInfoPaletteRGB(BaseModel):
 
     def to_json(self) -> str:
         """Returns the JSON representation of the model using alias"""
-        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
-        return json.dumps(self.to_dict())
+        return json.dumps(to_jsonable_python(self.to_dict()))
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:

twitter_openapi_python_generated/models/article_cover_media_info.py

@@ -24,6 +24,7 @@ from twitter_openapi_python_generated.models.article_cover_media_color_info impo
 from twitter_openapi_python_generated.models.type_name import TypeName
 from typing import Optional, Set
 from typing_extensions import Self
+from pydantic_core import to_jsonable_python
 
 class ArticleCoverMediaInfo(BaseModel):
     """
@@ -37,7 +38,8 @@ class ArticleCoverMediaInfo(BaseModel):
     __properties: ClassVar[List[str]] = ["__typename", "color_info", "original_img_height", "original_img_url", "original_img_width"]
 
     model_config = ConfigDict(
-        populate_by_name=True,
+        validate_by_name=True,
+        validate_by_alias=True,
         validate_assignment=True,
         protected_namespaces=(),
     )
@@ -49,8 +51,7 @@ class ArticleCoverMediaInfo(BaseModel):
 
     def to_json(self) -> str:
         """Returns the JSON representation of the model using alias"""
-        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
-        return json.dumps(self.to_dict())
+        return json.dumps(to_jsonable_python(self.to_dict()))
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:

twitter_openapi_python_generated/models/article_lifecycle_state.py

@@ -22,6 +22,7 @@ from pydantic import BaseModel, ConfigDict, StrictInt
 from typing import Any, ClassVar, Dict, List
 from typing import Optional, Set
 from typing_extensions import Self
+from pydantic_core import to_jsonable_python
 
 class ArticleLifecycleState(BaseModel):
     """
@@ -31,7 +32,8 @@ class ArticleLifecycleState(BaseModel):
     __properties: ClassVar[List[str]] = ["modified_at_secs"]
 
     model_config = ConfigDict(
-        populate_by_name=True,
+        validate_by_name=True,
+        validate_by_alias=True,
         validate_assignment=True,
         protected_namespaces=(),
     )
@@ -43,8 +45,7 @@ class ArticleLifecycleState(BaseModel):
 
     def to_json(self) -> str:
         """Returns the JSON representation of the model using alias"""
-        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
-        return json.dumps(self.to_dict())
+        return json.dumps(to_jsonable_python(self.to_dict()))
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:

twitter_openapi_python_generated/models/article_metadata.py

@@ -22,6 +22,7 @@ from pydantic import BaseModel, ConfigDict, StrictInt
 from typing import Any, ClassVar, Dict, List
 from typing import Optional, Set
 from typing_extensions import Self
+from pydantic_core import to_jsonable_python
 
 class ArticleMetadata(BaseModel):
     """
@@ -31,7 +32,8 @@ class ArticleMetadata(BaseModel):
     __properties: ClassVar[List[str]] = ["first_published_at_secs"]
 
     model_config = ConfigDict(
-        populate_by_name=True,
+        validate_by_name=True,
+        validate_by_alias=True,
         validate_assignment=True,
         protected_namespaces=(),
     )
@@ -43,8 +45,7 @@ class ArticleMetadata(BaseModel):
 
     def to_json(self) -> str:
         """Returns the JSON representation of the model using alias"""
-        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
-        return json.dumps(self.to_dict())
+        return json.dumps(to_jsonable_python(self.to_dict()))
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:

twitter_openapi_python_generated/models/article_preview.py

@@ -0,0 +1,99 @@
+# coding: utf-8
+
+"""
+    Twitter OpenAPI
+
+    Twitter OpenAPI(Swagger) specification
+
+    The version of the OpenAPI document: 0.0.1
+    Contact: yuki@yuki0311.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from twitter_openapi_python_generated.models.article_cover_media import ArticleCoverMedia
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class ArticlePreview(BaseModel):
+    """
+    ArticlePreview
+    """ # noqa: E501
+    article_id: StrictInt
+    cover_media: Optional[ArticleCoverMedia] = None
+    preview_text: StrictStr
+    title: StrictStr
+    __properties: ClassVar[List[str]] = ["article_id", "cover_media", "preview_text", "title"]
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(to_jsonable_python(self.to_dict()))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of ArticlePreview from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of cover_media
+        if self.cover_media:
+            _dict['cover_media'] = self.cover_media.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ArticlePreview from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "article_id": obj.get("article_id"),
+            "cover_media": ArticleCoverMedia.from_dict(obj["cover_media"]) if obj.get("cover_media") is not None else None,
+            "preview_text": obj.get("preview_text"),
+            "title": obj.get("title")
+        })
+        return _obj
+
+

twitter_openapi_python_generated/models/article_result.py

@@ -18,7 +18,7 @@ import pprint
 import re  # noqa: F401
 import json
 
-from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr, field_validator
 from typing import Any, ClassVar, Dict, List, Optional
 from typing_extensions import Annotated
 from twitter_openapi_python_generated.models.article_cover_media import ArticleCoverMedia
@@ -26,29 +26,34 @@ from twitter_openapi_python_generated.models.article_lifecycle_state import Arti
 from twitter_openapi_python_generated.models.article_metadata import ArticleMetadata
 from typing import Optional, Set
 from typing_extensions import Self
+from pydantic_core import to_jsonable_python
 
 class ArticleResult(BaseModel):
     """
     ArticleResult
     """ # noqa: E501
-    cover_media: ArticleCoverMedia
+    content_state: Optional[Dict[str, Any]] = None
+    cover_media: Optional[ArticleCoverMedia] = None
     id: StrictStr
+    is_grok_summary_eligible: Optional[StrictBool] = None
     lifecycle_state: Optional[ArticleLifecycleState] = None
+    media_entities: Optional[List[ArticleCoverMedia]] = None
     metadata: ArticleMetadata
     preview_text: StrictStr
     rest_id: Annotated[str, Field(strict=True)]
     title: StrictStr
-    __properties: ClassVar[List[str]] = ["cover_media", "id", "lifecycle_state", "metadata", "preview_text", "rest_id", "title"]
+    __properties: ClassVar[List[str]] = ["content_state", "cover_media", "id", "is_grok_summary_eligible", "lifecycle_state", "media_entities", "metadata", "preview_text", "rest_id", "title"]
 
-    @field_validator('rest_id')
+    @field_validator('rest_id', mode="before")
     def rest_id_validate_regular_expression(cls, value):
         """Validates the regular expression"""
-        if not re.match(r"^[0-9]+$", value):
+        if isinstance(value, str) and not re.match(r"^[0-9]+$", value):
             raise ValueError(r"must validate the regular expression /^[0-9]+$/")
         return value
 
     model_config = ConfigDict(
-        populate_by_name=True,
+        validate_by_name=True,
+        validate_by_alias=True,
         validate_assignment=True,
         protected_namespaces=(),
     )
@@ -60,8 +65,7 @@ class ArticleResult(BaseModel):
 
     def to_json(self) -> str:
         """Returns the JSON representation of the model using alias"""
-        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
-        return json.dumps(self.to_dict())
+        return json.dumps(to_jsonable_python(self.to_dict()))
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:
@@ -92,6 +96,12 @@ class ArticleResult(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of lifecycle_state
         if self.lifecycle_state:
             _dict['lifecycle_state'] = self.lifecycle_state.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in media_entities (list)
+        _items = []
+        if self.media_entities:
+            for _item_media_entities in self.media_entities:
+                _items.append(_item_media_entities.to_dict() if _item_media_entities is not None else None)
+            _dict['media_entities'] = _items
         # override the default output from pydantic by calling `to_dict()` of metadata
         if self.metadata:
             _dict['metadata'] = self.metadata.to_dict()
@@ -107,9 +117,12 @@ class ArticleResult(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
+            "content_state": obj.get("content_state"),
             "cover_media": ArticleCoverMedia.from_dict(obj["cover_media"]) if obj.get("cover_media") is not None else None,
             "id": obj.get("id"),
+            "is_grok_summary_eligible": obj.get("is_grok_summary_eligible"),
             "lifecycle_state": ArticleLifecycleState.from_dict(obj["lifecycle_state"]) if obj.get("lifecycle_state") is not None else None,
+            "media_entities": [ArticleCoverMedia.from_dict(_item) for _item in obj["media_entities"]] if obj.get("media_entities") is not None else None,
             "metadata": ArticleMetadata.from_dict(obj["metadata"]) if obj.get("metadata") is not None else None,
             "preview_text": obj.get("preview_text"),
             "rest_id": obj.get("rest_id"),

twitter_openapi_python_generated/models/article_results.py

@@ -23,6 +23,7 @@ from typing import Any, ClassVar, Dict, List
 from twitter_openapi_python_generated.models.article_result import ArticleResult
 from typing import Optional, Set
 from typing_extensions import Self
+from pydantic_core import to_jsonable_python
 
 class ArticleResults(BaseModel):
     """
@@ -32,7 +33,8 @@ class ArticleResults(BaseModel):
     __properties: ClassVar[List[str]] = ["result"]
 
     model_config = ConfigDict(
-        populate_by_name=True,
+        validate_by_name=True,
+        validate_by_alias=True,
         validate_assignment=True,
         protected_namespaces=(),
     )
@@ -44,8 +46,7 @@ class ArticleResults(BaseModel):
 
     def to_json(self) -> str:
         """Returns the JSON representation of the model using alias"""
-        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
-        return json.dumps(self.to_dict())
+        return json.dumps(to_jsonable_python(self.to_dict()))
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:

twitter_openapi_python_generated/models/author_community_relationship.py

@@ -20,16 +20,17 @@ import json
 
 from pydantic import BaseModel, ConfigDict, StrictStr, field_validator
 from typing import Any, ClassVar, Dict, List, Optional
-from twitter_openapi_python_generated.models.community import Community
+from twitter_openapi_python_generated.models.community_result import CommunityResult
 from twitter_openapi_python_generated.models.user_results import UserResults
 from typing import Optional, Set
 from typing_extensions import Self
+from pydantic_core import to_jsonable_python
 
 class AuthorCommunityRelationship(BaseModel):
     """
     AuthorCommunityRelationship
     """ # noqa: E501
-    community_results: Community
+    community_results: CommunityResult
     role: Optional[StrictStr] = None
     user_results: Optional[UserResults] = None
     __properties: ClassVar[List[str]] = ["community_results", "role", "user_results"]
@@ -40,12 +41,13 @@ class AuthorCommunityRelationship(BaseModel):
         if value is None:
             return value
 
-        if value not in set(['Member', 'Moderator', 'Admin']):
-            raise ValueError("must be one of enum values ('Member', 'Moderator', 'Admin')")
+        if value not in set(['Member', 'Moderator', 'Admin', 'NonMember']):
+            raise ValueError("must be one of enum values ('Member', 'Moderator', 'Admin', 'NonMember')")
         return value
 
     model_config = ConfigDict(
-        populate_by_name=True,
+        validate_by_name=True,
+        validate_by_alias=True,
         validate_assignment=True,
         protected_namespaces=(),
     )
@@ -57,8 +59,7 @@ class AuthorCommunityRelationship(BaseModel):
 
     def to_json(self) -> str:
         """Returns the JSON representation of the model using alias"""
-        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
-        return json.dumps(self.to_dict())
+        return json.dumps(to_jsonable_python(self.to_dict()))
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:
@@ -101,7 +102,7 @@ class AuthorCommunityRelationship(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
-            "community_results": Community.from_dict(obj["community_results"]) if obj.get("community_results") is not None else None,
+            "community_results": CommunityResult.from_dict(obj["community_results"]) if obj.get("community_results") is not None else None,
             "role": obj.get("role"),
             "user_results": UserResults.from_dict(obj["user_results"]) if obj.get("user_results") is not None else None
         })

twitter_openapi_python_generated/models/badge_counts.py

@@ -0,0 +1,97 @@
+# coding: utf-8
+
+"""
+    Twitter OpenAPI
+
+    Twitter OpenAPI(Swagger) specification
+
+    The version of the OpenAPI document: 0.0.1
+    Contact: yuki@yuki0311.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictBool, StrictInt
+from typing import Any, ClassVar, Dict, List
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class BadgeCounts(BaseModel):
+    """
+    BadgeCounts
+    """ # noqa: E501
+    dm_unread_count: StrictInt
+    is_from_urt: StrictBool
+    ntab_unread_count: StrictInt
+    total_unread_count: StrictInt
+    xchat_unread_count: StrictInt
+    __properties: ClassVar[List[str]] = ["dm_unread_count", "is_from_urt", "ntab_unread_count", "total_unread_count", "xchat_unread_count"]
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(to_jsonable_python(self.to_dict()))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of BadgeCounts from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of BadgeCounts from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "dm_unread_count": obj.get("dm_unread_count"),
+            "is_from_urt": obj.get("is_from_urt"),
+            "ntab_unread_count": obj.get("ntab_unread_count"),
+            "total_unread_count": obj.get("total_unread_count"),
+            "xchat_unread_count": obj.get("xchat_unread_count")
+        })
+        return _obj
+
+

twitter_openapi_python_generated/models/birdwatch_entity.py

@@ -23,6 +23,7 @@ from typing import Any, ClassVar, Dict, List
 from twitter_openapi_python_generated.models.birdwatch_entity_ref import BirdwatchEntityRef
 from typing import Optional, Set
 from typing_extensions import Self
+from pydantic_core import to_jsonable_python
 
 class BirdwatchEntity(BaseModel):
     """
@@ -34,7 +35,8 @@ class BirdwatchEntity(BaseModel):
     __properties: ClassVar[List[str]] = ["fromIndex", "ref", "toIndex"]
 
     model_config = ConfigDict(
-        populate_by_name=True,
+        validate_by_name=True,
+        validate_by_alias=True,
         validate_assignment=True,
         protected_namespaces=(),
     )
@@ -46,8 +48,7 @@ class BirdwatchEntity(BaseModel):
 
     def to_json(self) -> str:
         """Returns the JSON representation of the model using alias"""
-        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
-        return json.dumps(self.to_dict())
+        return json.dumps(to_jsonable_python(self.to_dict()))
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:

twitter_openapi_python_generated/models/birdwatch_entity_ref.py

@@ -22,16 +22,18 @@ from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
 from typing import Any, ClassVar, Dict, List, Optional
 from typing import Optional, Set
 from typing_extensions import Self
+from pydantic_core import to_jsonable_python
 
 class BirdwatchEntityRef(BaseModel):
     """
     BirdwatchEntityRef
     """ # noqa: E501
+    expanded_url: Optional[StrictStr] = Field(default=None, alias="expandedUrl")
     text: Optional[StrictStr] = None
     type: StrictStr
     url: Optional[StrictStr] = None
     url_type: Optional[StrictStr] = Field(default=None, alias="urlType")
-    __properties: ClassVar[List[str]] = ["text", "type", "url", "urlType"]
+    __properties: ClassVar[List[str]] = ["expandedUrl", "text", "type", "url", "urlType"]
 
     @field_validator('type')
     def type_validate_enum(cls, value):
@@ -51,7 +53,8 @@ class BirdwatchEntityRef(BaseModel):
         return value
 
     model_config = ConfigDict(
-        populate_by_name=True,
+        validate_by_name=True,
+        validate_by_alias=True,
         validate_assignment=True,
         protected_namespaces=(),
     )
@@ -63,8 +66,7 @@ class BirdwatchEntityRef(BaseModel):
 
     def to_json(self) -> str:
         """Returns the JSON representation of the model using alias"""
-        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
-        return json.dumps(self.to_dict())
+        return json.dumps(to_jsonable_python(self.to_dict()))
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:
@@ -101,6 +103,7 @@ class BirdwatchEntityRef(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
+            "expandedUrl": obj.get("expandedUrl"),
             "text": obj.get("text"),
             "type": obj.get("type"),
             "url": obj.get("url"),