Map Api

@validate_call
async def get_map_markers(
    self,
    file_created_after: Annotated[
        Optional[datetime],
        Field(description="Filter assets created after this date"),
    ] = None,
    file_created_before: Annotated[
        Optional[datetime],
        Field(description="Filter assets created before this date"),
    ] = None,
    is_archived: Annotated[
        Optional[StrictBool], Field(description="Filter by archived status")
    ] = None,
    is_favorite: Annotated[
        Optional[StrictBool], Field(description="Filter by favorite status")
    ] = None,
    with_partners: Annotated[
        Optional[StrictBool], Field(description="Include partner assets")
    ] = None,
    with_shared_albums: Annotated[
        Optional[StrictBool], Field(description="Include shared album assets")
    ] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]
        ],
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> List[MapMarkerResponseDto]:
    """Retrieve map markers

    Retrieve a list of latitude and longitude coordinates for every asset with location data.

    :param file_created_after: Filter assets created after this date
    :type file_created_after: datetime
    :param file_created_before: Filter assets created before this date
    :type file_created_before: datetime
    :param is_archived: Filter by archived status
    :type is_archived: bool
    :param is_favorite: Filter by favorite status
    :type is_favorite: bool
    :param with_partners: Include partner assets
    :type with_partners: bool
    :param with_shared_albums: Include shared album assets
    :type with_shared_albums: bool
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """  # noqa: E501

    _param = self._get_map_markers_serialize(
        file_created_after=file_created_after,
        file_created_before=file_created_before,
        is_archived=is_archived,
        is_favorite=is_favorite,
        with_partners=with_partners,
        with_shared_albums=with_shared_albums,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index,
    )

    _response_types_map: Dict[str, Optional[str]] = {
        "200": "List[MapMarkerResponseDto]",
    }
    response_data = await self.api_client.call_api(
        *_param, _request_timeout=_request_timeout
    )
    await response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

@validate_call
async def get_map_markers_with_http_info(
    self,
    file_created_after: Annotated[
        Optional[datetime],
        Field(description="Filter assets created after this date"),
    ] = None,
    file_created_before: Annotated[
        Optional[datetime],
        Field(description="Filter assets created before this date"),
    ] = None,
    is_archived: Annotated[
        Optional[StrictBool], Field(description="Filter by archived status")
    ] = None,
    is_favorite: Annotated[
        Optional[StrictBool], Field(description="Filter by favorite status")
    ] = None,
    with_partners: Annotated[
        Optional[StrictBool], Field(description="Include partner assets")
    ] = None,
    with_shared_albums: Annotated[
        Optional[StrictBool], Field(description="Include shared album assets")
    ] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]
        ],
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[List[MapMarkerResponseDto]]:
    """Retrieve map markers

    Retrieve a list of latitude and longitude coordinates for every asset with location data.

    :param file_created_after: Filter assets created after this date
    :type file_created_after: datetime
    :param file_created_before: Filter assets created before this date
    :type file_created_before: datetime
    :param is_archived: Filter by archived status
    :type is_archived: bool
    :param is_favorite: Filter by favorite status
    :type is_favorite: bool
    :param with_partners: Include partner assets
    :type with_partners: bool
    :param with_shared_albums: Include shared album assets
    :type with_shared_albums: bool
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """  # noqa: E501

    _param = self._get_map_markers_serialize(
        file_created_after=file_created_after,
        file_created_before=file_created_before,
        is_archived=is_archived,
        is_favorite=is_favorite,
        with_partners=with_partners,
        with_shared_albums=with_shared_albums,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index,
    )

    _response_types_map: Dict[str, Optional[str]] = {
        "200": "List[MapMarkerResponseDto]",
    }
    response_data = await self.api_client.call_api(
        *_param, _request_timeout=_request_timeout
    )
    await response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

@validate_call
async def get_map_markers_without_preload_content(
    self,
    file_created_after: Annotated[
        Optional[datetime],
        Field(description="Filter assets created after this date"),
    ] = None,
    file_created_before: Annotated[
        Optional[datetime],
        Field(description="Filter assets created before this date"),
    ] = None,
    is_archived: Annotated[
        Optional[StrictBool], Field(description="Filter by archived status")
    ] = None,
    is_favorite: Annotated[
        Optional[StrictBool], Field(description="Filter by favorite status")
    ] = None,
    with_partners: Annotated[
        Optional[StrictBool], Field(description="Include partner assets")
    ] = None,
    with_shared_albums: Annotated[
        Optional[StrictBool], Field(description="Include shared album assets")
    ] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]
        ],
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve map markers

    Retrieve a list of latitude and longitude coordinates for every asset with location data.

    :param file_created_after: Filter assets created after this date
    :type file_created_after: datetime
    :param file_created_before: Filter assets created before this date
    :type file_created_before: datetime
    :param is_archived: Filter by archived status
    :type is_archived: bool
    :param is_favorite: Filter by favorite status
    :type is_favorite: bool
    :param with_partners: Include partner assets
    :type with_partners: bool
    :param with_shared_albums: Include shared album assets
    :type with_shared_albums: bool
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """  # noqa: E501

    _param = self._get_map_markers_serialize(
        file_created_after=file_created_after,
        file_created_before=file_created_before,
        is_archived=is_archived,
        is_favorite=is_favorite,
        with_partners=with_partners,
        with_shared_albums=with_shared_albums,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index,
    )

    _response_types_map: Dict[str, Optional[str]] = {
        "200": "List[MapMarkerResponseDto]",
    }
    response_data = await self.api_client.call_api(
        *_param, _request_timeout=_request_timeout
    )
    return response_data.response

@validate_call
async def reverse_geocode(
    self,
    lat: Annotated[
        Union[StrictFloat, StrictInt], Field(description="Latitude (-90 to 90)")
    ],
    lon: Annotated[
        Union[StrictFloat, StrictInt], Field(description="Longitude (-180 to 180)")
    ],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]
        ],
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> List[MapReverseGeocodeResponseDto]:
    """Reverse geocode coordinates

    Retrieve location information (e.g., city, country) for given latitude and longitude coordinates.

    :param lat: Latitude (-90 to 90) (required)
    :type lat: float
    :param lon: Longitude (-180 to 180) (required)
    :type lon: float
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """  # noqa: E501

    _param = self._reverse_geocode_serialize(
        lat=lat,
        lon=lon,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index,
    )

    _response_types_map: Dict[str, Optional[str]] = {
        "200": "List[MapReverseGeocodeResponseDto]",
    }
    response_data = await self.api_client.call_api(
        *_param, _request_timeout=_request_timeout
    )
    await response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

@validate_call
async def reverse_geocode_with_http_info(
    self,
    lat: Annotated[
        Union[StrictFloat, StrictInt], Field(description="Latitude (-90 to 90)")
    ],
    lon: Annotated[
        Union[StrictFloat, StrictInt], Field(description="Longitude (-180 to 180)")
    ],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]
        ],
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[List[MapReverseGeocodeResponseDto]]:
    """Reverse geocode coordinates

    Retrieve location information (e.g., city, country) for given latitude and longitude coordinates.

    :param lat: Latitude (-90 to 90) (required)
    :type lat: float
    :param lon: Longitude (-180 to 180) (required)
    :type lon: float
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """  # noqa: E501

    _param = self._reverse_geocode_serialize(
        lat=lat,
        lon=lon,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index,
    )

    _response_types_map: Dict[str, Optional[str]] = {
        "200": "List[MapReverseGeocodeResponseDto]",
    }
    response_data = await self.api_client.call_api(
        *_param, _request_timeout=_request_timeout
    )
    await response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

@validate_call
async def reverse_geocode_without_preload_content(
    self,
    lat: Annotated[
        Union[StrictFloat, StrictInt], Field(description="Latitude (-90 to 90)")
    ],
    lon: Annotated[
        Union[StrictFloat, StrictInt], Field(description="Longitude (-180 to 180)")
    ],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]
        ],
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Reverse geocode coordinates

    Retrieve location information (e.g., city, country) for given latitude and longitude coordinates.

    :param lat: Latitude (-90 to 90) (required)
    :type lat: float
    :param lon: Longitude (-180 to 180) (required)
    :type lon: float
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """  # noqa: E501

    _param = self._reverse_geocode_serialize(
        lat=lat,
        lon=lon,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index,
    )

    _response_types_map: Dict[str, Optional[str]] = {
        "200": "List[MapReverseGeocodeResponseDto]",
    }
    response_data = await self.api_client.call_api(
        *_param, _request_timeout=_request_timeout
    )
    return response_data.response