stadiamaps 3.2.1__py3-none-any.whl → 5.0.0__py3-none-any.whl

stadiamaps/models/osrm_base_api_response.py

@@ -0,0 +1,112 @@
+# coding: utf-8
+
+"""
+    Stadia Maps Geospatial APIs
+
+    The Stadia Maps Geospatial APIs provide you with the data you need to build awesome applications.
+
+    The version of the OpenAPI document: 8.0.0
+    Contact: support@stadiamaps.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, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class OsrmBaseApiResponse(BaseModel):
+    """
+    OsrmBaseApiResponse
+    """ # noqa: E501
+    code: StrictStr
+    message: Optional[StrictStr] = None
+    data_version: Optional[StrictStr] = None
+    additional_properties: Dict[str, Any] = {}
+    __properties: ClassVar[List[str]] = ["code", "message", "data_version"]
+
+    @field_validator('code')
+    def code_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(['Ok', 'InvalidUrl', 'InvalidService', 'InvalidVersion', 'InvalidOptions', 'InvalidQuery', 'InvalidValue', 'NoSegment', 'TooBig', 'NoRoute', 'NoTable', 'NotImplemented', 'NoTrips']):
+            raise ValueError("must be one of enum values ('Ok', 'InvalidUrl', 'InvalidService', 'InvalidVersion', 'InvalidOptions', 'InvalidQuery', 'InvalidValue', 'NoSegment', 'TooBig', 'NoRoute', 'NoTable', 'NotImplemented', 'NoTrips')")
+        return value
+
+    model_config = ConfigDict(
+        populate_by_name=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"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of OsrmBaseApiResponse 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.
+        * Fields in `self.additional_properties` are added to the output dict.
+        """
+        excluded_fields: Set[str] = set([
+            "additional_properties",
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # puts key-value pairs in additional_properties in the top level
+        if self.additional_properties is not None:
+            for _key, _value in self.additional_properties.items():
+                _dict[_key] = _value
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of OsrmBaseApiResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "code": obj.get("code"),
+            "message": obj.get("message"),
+            "data_version": obj.get("data_version")
+        })
+        # store additional fields in additional_properties
+        for _key in obj.keys():
+            if _key not in cls.__properties:
+                _obj.additional_properties[_key] = obj.get(_key)
+
+        return _obj
+
+

stadiamaps/models/osrm_guidance_modifier.py

@@ -0,0 +1,44 @@
+# coding: utf-8
+
+"""
+    Stadia Maps Geospatial APIs
+
+    The Stadia Maps Geospatial APIs provide you with the data you need to build awesome applications.
+
+    The version of the OpenAPI document: 8.0.0
+    Contact: support@stadiamaps.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import json
+from enum import Enum
+from typing_extensions import Self
+
+
+class OsrmGuidanceModifier(str, Enum):
+    """
+    An optional value indicating the directional change of the maneuver (further clarifying type).
+    """
+
+    """
+    allowed enum values
+    """
+    UTURN = 'uturn'
+    SHARP_RIGHT = 'sharp right'
+    RIGHT = 'right'
+    SLIGHT_RIGHT = 'slight right'
+    STRAIGHT = 'straight'
+    SLIGHT_LEFT = 'slight left'
+    LEFT = 'left'
+    SHARP_LEFT = 'sharp left'
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self:
+        """Create an instance of OsrmGuidanceModifier from a JSON string"""
+        return cls(json.loads(json_str))
+
+

stadiamaps/models/osrm_intersection.py

@@ -0,0 +1,145 @@
+# coding: utf-8
+
+"""
+    Stadia Maps Geospatial APIs
+
+    The Stadia Maps Geospatial APIs provide you with the data you need to build awesome applications.
+
+    The version of the OpenAPI document: 8.0.0
+    Contact: support@stadiamaps.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, Field, StrictBool, StrictFloat, StrictInt, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from typing_extensions import Annotated
+from stadiamaps.models.osrm_lane import OsrmLane
+from typing import Optional, Set
+from typing_extensions import Self
+
+class OsrmIntersection(BaseModel):
+    """
+    Detailed information about intersections that the route traverses. For every step, the first intersection is at the location of the maneuver. Additional intersections will be provided for every road or path traversed until the next step.
+    """ # noqa: E501
+    location: Annotated[List[Union[StrictFloat, StrictInt]], Field(min_length=2, max_length=2)] = Field(description="A (longitude, latitude) coordinate pair.")
+    bearings: List[StrictInt] = Field(description="A list of bearing values that are available for travel through the intersection.")
+    classes: Optional[List[StrictStr]] = None
+    entry: List[StrictBool] = Field(description="A list of entry flags, which map 1:1 to the bearings. A value of true indicates that the respective road could be entered on a valid route. False indicates that the turn onto the respective road would violate a restriction.")
+    var_in: Optional[StrictInt] = Field(default=None, description="An index into bearings/entry array. Used to calculate the bearing just before the turn. Namely, the clockwise angle from true north to the direction of travel immediately before the maneuver/passing the intersection. Bearings are given relative to the intersection. To get the bearing in the direction of driving, the bearing has to be rotated by a value of 180. The value is not supplied for depart maneuvers.", alias="in")
+    out: Optional[StrictInt] = Field(default=None, description="An index into bearings/entry array. Used to calculate the bearing just after the turn. Namely, the clockwise angle from true north to the direction of travel immediately after the maneuver/passing the intersection. This is not supplied for arrive maneuvers.")
+    lanes: Optional[List[OsrmLane]] = Field(default=None, description="Available turn lanes at the intersection. May be omitted if no lane information is available for the intersection.")
+    admin_index: Optional[StrictInt] = Field(default=None, description="The index into the admin boundaries list on the route leg.")
+    duration: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, description="The estimated duration, in seconds, to traverse the intersection.")
+    turn_duration: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, description="The estimated duration, in seconds, to complete the turn.")
+    turn_weight: Optional[Union[StrictFloat, StrictInt]] = None
+    geometry_index: Optional[StrictInt] = Field(default=None, description="The index of the intersection in the leg geometry.")
+    weight: Optional[Union[StrictFloat, StrictInt]] = None
+    additional_properties: Dict[str, Any] = {}
+    __properties: ClassVar[List[str]] = ["location", "bearings", "classes", "entry", "in", "out", "lanes", "admin_index", "duration", "turn_duration", "turn_weight", "geometry_index", "weight"]
+
+    @field_validator('classes')
+    def classes_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        for i in value:
+            if i not in set(['toll', 'ferry', 'restricted', 'motorway', 'tunnel']):
+                raise ValueError("each list item must be one of ('toll', 'ferry', 'restricted', 'motorway', 'tunnel')")
+        return value
+
+    model_config = ConfigDict(
+        populate_by_name=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"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of OsrmIntersection 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.
+        * Fields in `self.additional_properties` are added to the output dict.
+        """
+        excluded_fields: Set[str] = set([
+            "additional_properties",
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of each item in lanes (list)
+        _items = []
+        if self.lanes:
+            for _item_lanes in self.lanes:
+                if _item_lanes:
+                    _items.append(_item_lanes.to_dict())
+            _dict['lanes'] = _items
+        # puts key-value pairs in additional_properties in the top level
+        if self.additional_properties is not None:
+            for _key, _value in self.additional_properties.items():
+                _dict[_key] = _value
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of OsrmIntersection from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "location": obj.get("location"),
+            "bearings": obj.get("bearings"),
+            "classes": obj.get("classes"),
+            "entry": obj.get("entry"),
+            "in": obj.get("in"),
+            "out": obj.get("out"),
+            "lanes": [OsrmLane.from_dict(_item) for _item in obj["lanes"]] if obj.get("lanes") is not None else None,
+            "admin_index": obj.get("admin_index"),
+            "duration": obj.get("duration"),
+            "turn_duration": obj.get("turn_duration"),
+            "turn_weight": obj.get("turn_weight"),
+            "geometry_index": obj.get("geometry_index"),
+            "weight": obj.get("weight")
+        })
+        # store additional fields in additional_properties
+        for _key in obj.keys():
+            if _key not in cls.__properties:
+                _obj.additional_properties[_key] = obj.get(_key)
+
+        return _obj
+
+

stadiamaps/models/osrm_lane.py

@@ -0,0 +1,111 @@
+# coding: utf-8
+
+"""
+    Stadia Maps Geospatial APIs
+
+    The Stadia Maps Geospatial APIs provide you with the data you need to build awesome applications.
+
+    The version of the OpenAPI document: 8.0.0
+    Contact: support@stadiamaps.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, Field, StrictBool, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List
+from typing import Optional, Set
+from typing_extensions import Self
+
+class OsrmLane(BaseModel):
+    """
+    OsrmLane
+    """ # noqa: E501
+    indications: List[StrictStr] = Field(description="A list of indication (e.g. marking on the road) specifying the turn lane. A road can have multiple indications (e.g. an arrow pointing straight and left).")
+    valid: StrictBool = Field(description="True if the lane is a valid choice for the current maneuver.")
+    additional_properties: Dict[str, Any] = {}
+    __properties: ClassVar[List[str]] = ["indications", "valid"]
+
+    @field_validator('indications')
+    def indications_validate_enum(cls, value):
+        """Validates the enum"""
+        for i in value:
+            if i not in set(['none', 'uturn', 'sharp right', 'right', 'slight right', 'straight', 'slight left', 'left', 'sharp left']):
+                raise ValueError("each list item must be one of ('none', 'uturn', 'sharp right', 'right', 'slight right', 'straight', 'slight left', 'left', 'sharp left')")
+        return value
+
+    model_config = ConfigDict(
+        populate_by_name=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"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of OsrmLane 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.
+        * Fields in `self.additional_properties` are added to the output dict.
+        """
+        excluded_fields: Set[str] = set([
+            "additional_properties",
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # puts key-value pairs in additional_properties in the top level
+        if self.additional_properties is not None:
+            for _key, _value in self.additional_properties.items():
+                _dict[_key] = _value
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of OsrmLane from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "indications": obj.get("indications"),
+            "valid": obj.get("valid")
+        })
+        # store additional fields in additional_properties
+        for _key in obj.keys():
+            if _key not in cls.__properties:
+                _obj.additional_properties[_key] = obj.get(_key)
+
+        return _obj
+
+

stadiamaps/models/osrm_route.py

@@ -0,0 +1,119 @@
+# coding: utf-8
+
+"""
+    Stadia Maps Geospatial APIs
+
+    The Stadia Maps Geospatial APIs provide you with the data you need to build awesome applications.
+
+    The version of the OpenAPI document: 8.0.0
+    Contact: support@stadiamaps.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, Field, StrictFloat, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from stadiamaps.models.osrm_route_leg import OsrmRouteLeg
+from typing import Optional, Set
+from typing_extensions import Self
+
+class OsrmRoute(BaseModel):
+    """
+    OsrmRoute
+    """ # noqa: E501
+    distance: Union[StrictFloat, StrictInt] = Field(description="The distance traveled by the route, in meters.")
+    duration: Union[StrictFloat, StrictInt] = Field(description="The estimated travel time, in number of seconds.")
+    geometry: StrictStr = Field(description="An encoded polyline (https://developers.google.com/maps/documentation/utilities/polylinealgorithm).")
+    weight: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, description="The total cost of the route computed by the routing engine.")
+    weight_name: Optional[StrictStr] = Field(default=None, description="The costing model used for the route.")
+    legs: List[OsrmRouteLeg]
+    additional_properties: Dict[str, Any] = {}
+    __properties: ClassVar[List[str]] = ["distance", "duration", "geometry", "weight", "weight_name", "legs"]
+
+    model_config = ConfigDict(
+        populate_by_name=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"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of OsrmRoute 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.
+        * Fields in `self.additional_properties` are added to the output dict.
+        """
+        excluded_fields: Set[str] = set([
+            "additional_properties",
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of each item in legs (list)
+        _items = []
+        if self.legs:
+            for _item_legs in self.legs:
+                if _item_legs:
+                    _items.append(_item_legs.to_dict())
+            _dict['legs'] = _items
+        # puts key-value pairs in additional_properties in the top level
+        if self.additional_properties is not None:
+            for _key, _value in self.additional_properties.items():
+                _dict[_key] = _value
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of OsrmRoute from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "distance": obj.get("distance"),
+            "duration": obj.get("duration"),
+            "geometry": obj.get("geometry"),
+            "weight": obj.get("weight"),
+            "weight_name": obj.get("weight_name"),
+            "legs": [OsrmRouteLeg.from_dict(_item) for _item in obj["legs"]] if obj.get("legs") is not None else None
+        })
+        # store additional fields in additional_properties
+        for _key in obj.keys():
+            if _key not in cls.__properties:
+                _obj.additional_properties[_key] = obj.get(_key)
+
+        return _obj
+
+

stadiamaps/models/osrm_route_leg.py

@@ -0,0 +1,148 @@
+# coding: utf-8
+
+"""
+    Stadia Maps Geospatial APIs
+
+    The Stadia Maps Geospatial APIs provide you with the data you need to build awesome applications.
+
+    The version of the OpenAPI document: 8.0.0
+    Contact: support@stadiamaps.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, Field, StrictFloat, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from stadiamaps.models.osrm_admin import OsrmAdmin
+from stadiamaps.models.osrm_annotation import OsrmAnnotation
+from stadiamaps.models.osrm_route_step import OsrmRouteStep
+from stadiamaps.models.osrm_via_waypoint import OsrmViaWaypoint
+from typing import Optional, Set
+from typing_extensions import Self
+
+class OsrmRouteLeg(BaseModel):
+    """
+    OsrmRouteLeg
+    """ # noqa: E501
+    distance: Union[StrictFloat, StrictInt] = Field(description="The distance traveled by the route, in meters.")
+    duration: Union[StrictFloat, StrictInt] = Field(description="The estimated travel time, in number of seconds.")
+    weight: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, description="The total cost of the leg computed by the routing engine.")
+    summary: Optional[StrictStr] = None
+    steps: List[OsrmRouteStep]
+    annotation: Optional[OsrmAnnotation] = None
+    via_waypoints: Optional[List[OsrmViaWaypoint]] = Field(default=None, description="Indicates which waypoints are passed through rather than creating a new leg.")
+    admins: Optional[List[OsrmAdmin]] = Field(default=None, description="Administrative regions visited along the leg.")
+    additional_properties: Dict[str, Any] = {}
+    __properties: ClassVar[List[str]] = ["distance", "duration", "weight", "summary", "steps", "annotation", "via_waypoints", "admins"]
+
+    model_config = ConfigDict(
+        populate_by_name=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"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of OsrmRouteLeg 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.
+        * Fields in `self.additional_properties` are added to the output dict.
+        """
+        excluded_fields: Set[str] = set([
+            "additional_properties",
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of each item in steps (list)
+        _items = []
+        if self.steps:
+            for _item_steps in self.steps:
+                if _item_steps:
+                    _items.append(_item_steps.to_dict())
+            _dict['steps'] = _items
+        # override the default output from pydantic by calling `to_dict()` of annotation
+        if self.annotation:
+            _dict['annotation'] = self.annotation.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in via_waypoints (list)
+        _items = []
+        if self.via_waypoints:
+            for _item_via_waypoints in self.via_waypoints:
+                if _item_via_waypoints:
+                    _items.append(_item_via_waypoints.to_dict())
+            _dict['via_waypoints'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in admins (list)
+        _items = []
+        if self.admins:
+            for _item_admins in self.admins:
+                if _item_admins:
+                    _items.append(_item_admins.to_dict())
+            _dict['admins'] = _items
+        # puts key-value pairs in additional_properties in the top level
+        if self.additional_properties is not None:
+            for _key, _value in self.additional_properties.items():
+                _dict[_key] = _value
+
+        # set to None if via_waypoints (nullable) is None
+        # and model_fields_set contains the field
+        if self.via_waypoints is None and "via_waypoints" in self.model_fields_set:
+            _dict['via_waypoints'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of OsrmRouteLeg from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "distance": obj.get("distance"),
+            "duration": obj.get("duration"),
+            "weight": obj.get("weight"),
+            "summary": obj.get("summary"),
+            "steps": [OsrmRouteStep.from_dict(_item) for _item in obj["steps"]] if obj.get("steps") is not None else None,
+            "annotation": OsrmAnnotation.from_dict(obj["annotation"]) if obj.get("annotation") is not None else None,
+            "via_waypoints": [OsrmViaWaypoint.from_dict(_item) for _item in obj["via_waypoints"]] if obj.get("via_waypoints") is not None else None,
+            "admins": [OsrmAdmin.from_dict(_item) for _item in obj["admins"]] if obj.get("admins") is not None else None
+        })
+        # store additional fields in additional_properties
+        for _key in obj.keys():
+            if _key not in cls.__properties:
+                _obj.additional_properties[_key] = obj.get(_key)
+
+        return _obj
+
+