stadiamaps 3.2.0__py3-none-any.whl → 4.0.0__py3-none-any.whl

stadiamaps/models/osrm_route_response.py

@@ -0,0 +1,132 @@
+# 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: 7.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 stadiamaps.models.osrm_route import OsrmRoute
+from stadiamaps.models.osrm_waypoint import OsrmWaypoint
+from typing import Optional, Set
+from typing_extensions import Self
+
+class OsrmRouteResponse(BaseModel):
+    """
+    OsrmRouteResponse
+    """ # noqa: E501
+    code: StrictStr
+    message: Optional[StrictStr] = None
+    data_version: Optional[StrictStr] = None
+    waypoints: Optional[List[OsrmWaypoint]] = None
+    routes: Optional[List[OsrmRoute]] = None
+    additional_properties: Dict[str, Any] = {}
+    __properties: ClassVar[List[str]] = ["code", "message", "data_version", "waypoints", "routes"]
+
+    @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 OsrmRouteResponse 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 waypoints (list)
+        _items = []
+        if self.waypoints:
+            for _item_waypoints in self.waypoints:
+                if _item_waypoints:
+                    _items.append(_item_waypoints.to_dict())
+            _dict['waypoints'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in routes (list)
+        _items = []
+        if self.routes:
+            for _item_routes in self.routes:
+                if _item_routes:
+                    _items.append(_item_routes.to_dict())
+            _dict['routes'] = _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 OsrmRouteResponse 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"),
+            "waypoints": [OsrmWaypoint.from_dict(_item) for _item in obj["waypoints"]] if obj.get("waypoints") is not None else None,
+            "routes": [OsrmRoute.from_dict(_item) for _item in obj["routes"]] if obj.get("routes") 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_step.py

@@ -0,0 +1,185 @@
+# 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: 7.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, field_validator
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from stadiamaps.models.osrm_banner_instruction import OsrmBannerInstruction
+from stadiamaps.models.osrm_intersection import OsrmIntersection
+from stadiamaps.models.osrm_step_maneuver import OsrmStepManeuver
+from stadiamaps.models.osrm_voice_instruction import OsrmVoiceInstruction
+from typing import Optional, Set
+from typing_extensions import Self
+
+class OsrmRouteStep(BaseModel):
+    """
+    A maneuver such as a turn or merge, followed by travel along a single road or path.
+    """ # 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) with 6 digits of decimal precision.")
+    weight: Optional[Union[StrictFloat, StrictInt]] = None
+    name: Optional[StrictStr] = Field(default=None, description="The name of the segment (ex: road) being traversed")
+    ref: Optional[StrictStr] = Field(default=None, description="A reference number of code for the segment being traversed.")
+    pronunciation: Optional[StrictStr] = Field(default=None, description="Pronunciation of the name (if available). The format of this varies by implementation/vendor.")
+    destinations: Optional[StrictStr] = None
+    exits: Optional[StrictStr] = None
+    mode: StrictStr = Field(description="The mode of travel.")
+    maneuver: OsrmStepManeuver
+    intersections: Optional[List[OsrmIntersection]] = None
+    rotary_name: Optional[StrictStr] = Field(default=None, description="The name of the traffic circle.")
+    rotary_pronunciation: Optional[StrictStr] = Field(default=None, description="Pronunciation of the rotary name (if available). The format of this varies by implementation/vendor.")
+    driving_side: Optional[StrictStr] = Field(default=None, description="The side of the road on which driving is legal for this step.")
+    voice_instructions: Optional[List[OsrmVoiceInstruction]] = Field(default=None, description="A list of announcements which should be spoken at various points along the maneuver.", alias="voiceInstructions")
+    banner_instructions: Optional[List[OsrmBannerInstruction]] = Field(default=None, description="A list of announcements which should be displayed prominently on screen at various points along the maneuver.", alias="bannerInstructions")
+    speed_limit_sign: Optional[StrictStr] = Field(default=None, description="The style of speed limit signs used along the step.", alias="speedLimitSign")
+    speed_limit_unit: Optional[StrictStr] = Field(default=None, description="The unit of measure that is used locally along the step. This may be different from the unit used in maxspeed annotations, and is provided so that apps can localize their display.", alias="speedLimitUnit")
+    additional_properties: Dict[str, Any] = {}
+    __properties: ClassVar[List[str]] = ["distance", "duration", "geometry", "weight", "name", "ref", "pronunciation", "destinations", "exits", "mode", "maneuver", "intersections", "rotary_name", "rotary_pronunciation", "driving_side", "voiceInstructions", "bannerInstructions", "speedLimitSign", "speedLimitUnit"]
+
+    @field_validator('driving_side')
+    def driving_side_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['left', 'right']):
+            raise ValueError("must be one of enum values ('left', 'right')")
+        return value
+
+    @field_validator('speed_limit_sign')
+    def speed_limit_sign_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['mutcd', 'vienna']):
+            raise ValueError("must be one of enum values ('mutcd', 'vienna')")
+        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 OsrmRouteStep 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 maneuver
+        if self.maneuver:
+            _dict['maneuver'] = self.maneuver.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in intersections (list)
+        _items = []
+        if self.intersections:
+            for _item_intersections in self.intersections:
+                if _item_intersections:
+                    _items.append(_item_intersections.to_dict())
+            _dict['intersections'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in voice_instructions (list)
+        _items = []
+        if self.voice_instructions:
+            for _item_voice_instructions in self.voice_instructions:
+                if _item_voice_instructions:
+                    _items.append(_item_voice_instructions.to_dict())
+            _dict['voiceInstructions'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in banner_instructions (list)
+        _items = []
+        if self.banner_instructions:
+            for _item_banner_instructions in self.banner_instructions:
+                if _item_banner_instructions:
+                    _items.append(_item_banner_instructions.to_dict())
+            _dict['bannerInstructions'] = _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 OsrmRouteStep 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"),
+            "name": obj.get("name"),
+            "ref": obj.get("ref"),
+            "pronunciation": obj.get("pronunciation"),
+            "destinations": obj.get("destinations"),
+            "exits": obj.get("exits"),
+            "mode": obj.get("mode"),
+            "maneuver": OsrmStepManeuver.from_dict(obj["maneuver"]) if obj.get("maneuver") is not None else None,
+            "intersections": [OsrmIntersection.from_dict(_item) for _item in obj["intersections"]] if obj.get("intersections") is not None else None,
+            "rotary_name": obj.get("rotary_name"),
+            "rotary_pronunciation": obj.get("rotary_pronunciation"),
+            "driving_side": obj.get("driving_side"),
+            "voiceInstructions": [OsrmVoiceInstruction.from_dict(_item) for _item in obj["voiceInstructions"]] if obj.get("voiceInstructions") is not None else None,
+            "bannerInstructions": [OsrmBannerInstruction.from_dict(_item) for _item in obj["bannerInstructions"]] if obj.get("bannerInstructions") is not None else None,
+            "speedLimitSign": obj.get("speedLimitSign"),
+            "speedLimitUnit": obj.get("speedLimitUnit")
+        })
+        # 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_speed_limit.py

@@ -0,0 +1,117 @@
+# 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: 7.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, StrictInt, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class OsrmSpeedLimit(BaseModel):
+    """
+    The speed limit between the pair of coordinates.
+    """ # noqa: E501
+    speed: Optional[StrictInt] = None
+    unit: Optional[StrictStr] = Field(default=None, description="The unit of measure for the speed. Always included if speed is present.")
+    unknown: Optional[StrictBool] = Field(default=None, description="True if the speed limit is not known.")
+    var_none: Optional[StrictBool] = Field(default=None, description="True if there is no explicit speed limit (ex: some Autobahn sections)", alias="none")
+    additional_properties: Dict[str, Any] = {}
+    __properties: ClassVar[List[str]] = ["speed", "unit", "unknown", "none"]
+
+    @field_validator('unit')
+    def unit_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['km/h', 'mph']):
+            raise ValueError("must be one of enum values ('km/h', 'mph')")
+        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 OsrmSpeedLimit 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 OsrmSpeedLimit from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "speed": obj.get("speed"),
+            "unit": obj.get("unit"),
+            "unknown": obj.get("unknown"),
+            "none": obj.get("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_step_maneuver.py

@@ -0,0 +1,127 @@
+# 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: 7.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, field_validator
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from typing_extensions import Annotated
+from stadiamaps.models.osrm_guidance_modifier import OsrmGuidanceModifier
+from typing import Optional, Set
+from typing_extensions import Self
+
+class OsrmStepManeuver(BaseModel):
+    """
+    OsrmStepManeuver
+    """ # noqa: E501
+    location: Annotated[List[Union[StrictFloat, StrictInt]], Field(min_length=2, max_length=2)] = Field(description="A (longitude, latitude) coordinate pair.")
+    instruction: Optional[StrictStr] = Field(default=None, description="A human-readable instruction for the maneuver.")
+    bearing_before: StrictInt = Field(description="The clockwise angle from true north to the direction of travel immediately before the maneuver.")
+    bearing_after: StrictInt = Field(description="The clockwise angle from true north to the direction of travel immediately after the maneuver.")
+    type: StrictStr
+    modifier: Optional[OsrmGuidanceModifier] = None
+    exit: Optional[StrictInt] = Field(default=None, description="The exit number to take (for roundabouts, rotaries, and number of intersections).")
+    additional_properties: Dict[str, Any] = {}
+    __properties: ClassVar[List[str]] = ["location", "instruction", "bearing_before", "bearing_after", "type", "modifier", "exit"]
+
+    @field_validator('type')
+    def type_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(['turn', 'new name', 'depart', 'arrive', 'merge', 'ramp', 'on ramp', 'off ramp', 'fork', 'end of road', 'use lane', 'continue', 'roundabout', 'rotary', 'roundabout turn', 'notification']):
+            raise ValueError("must be one of enum values ('turn', 'new name', 'depart', 'arrive', 'merge', 'ramp', 'on ramp', 'off ramp', 'fork', 'end of road', 'use lane', 'continue', 'roundabout', 'rotary', 'roundabout turn', 'notification')")
+        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 OsrmStepManeuver 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
+
+        # set to None if modifier (nullable) is None
+        # and model_fields_set contains the field
+        if self.modifier is None and "modifier" in self.model_fields_set:
+            _dict['modifier'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of OsrmStepManeuver 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"),
+            "instruction": obj.get("instruction"),
+            "bearing_before": obj.get("bearing_before"),
+            "bearing_after": obj.get("bearing_after"),
+            "type": obj.get("type"),
+            "modifier": obj.get("modifier"),
+            "exit": obj.get("exit")
+        })
+        # 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_via_waypoint.py

@@ -0,0 +1,105 @@
+# 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: 7.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
+from typing import Any, ClassVar, Dict, List, Union
+from typing import Optional, Set
+from typing_extensions import Self
+
+class OsrmViaWaypoint(BaseModel):
+    """
+    OsrmViaWaypoint
+    """ # noqa: E501
+    distance_from_start: Union[StrictFloat, StrictInt] = Field(description="The distance from the start of the leg, in meters.")
+    geometry_index: StrictInt = Field(description="The index of the waypoint's location in the route geometry.")
+    waypoint_index: StrictInt = Field(description="The index of the associated waypoint.")
+    additional_properties: Dict[str, Any] = {}
+    __properties: ClassVar[List[str]] = ["distance_from_start", "geometry_index", "waypoint_index"]
+
+    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 OsrmViaWaypoint 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 OsrmViaWaypoint from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "distance_from_start": obj.get("distance_from_start"),
+            "geometry_index": obj.get("geometry_index"),
+            "waypoint_index": obj.get("waypoint_index")
+        })
+        # 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
+
+