# coding: utf-8

"""
    Eazyrent products API

    EazyRent Products API ======================  Description ------------  The EazyRent Product API offers a comprehensive solution for managing rental and sale listings, including property details, media distribution, and data import capabilities. Designed for real estate professionals, this API allows users to create, update, and manage property listings efficiently while ensuring accurate data and broad market reach. With features to streamline listing distribution and import property data from other platforms, the Product API simplifies property management, helping agencies maintain up-to-date and comprehensive property portfolios.  Target Audience -----------------   * **Real Estate Agencies and Social Housing Providers:** Professionals who need a centralized system to manage property listings, including rental and sale offerings, media distribution, and data synchronization across various platforms.   * **Property Managers:** Organizations looking to efficiently organize and promote property listings, manage property details, and ensure accurate, consistent information across marketing channels.  Purpose ---------  The purpose of the EazyRent Product API is to enable streamlined property management within the EazyRent platform. By integrating this API, businesses can centralize their property data, automate distribution to marketing channels, and simplify the process of keeping listings updated. This provides agencies with a scalable, efficient way to manage property portfolios, ensuring quick, effective exposure to potential tenants and buyers.  How to use this API ---------------------  To get started with the EazyRent Product API, please refer to our comprehensive documentation for authentication details, endpoint descriptions, and integration guides. This resource will help you set up efficient property management workflows, from data import to listing updates and distribution, all accessible within your existing systems.

    The version of the OpenAPI document: 1
    Generated by OpenAPI Generator (https://openapi-generator.tech)

    Do not edit the class manually.
"""  # noqa: E501

import warnings
from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
from typing import Any, Dict, List, Optional, Tuple, Union
from typing_extensions import Annotated

from datetime import datetime
from pydantic import (
    Field,
    StrictBool,
    StrictFloat,
    StrictInt,
    StrictStr,
    field_validator,
)
from typing import Any, Optional, Union
from typing_extensions import Annotated
from eazyrent.products.v1.models.mandate_type import MandateType
from eazyrent.products.v1.models.paginated_response_union_list_for_rent_product_list_for_sales_product import (
    PaginatedResponseUnionListForRentProductListForSalesProduct,
)
from eazyrent.products.v1.models.product import Product
from eazyrent.products.v1.models.product_type import ProductType
from eazyrent.products.v1.models.response_create_product import ResponseCreateProduct
from eazyrent.products.v1.models.response_get_product import ResponseGetProduct
from eazyrent.products.v1.models.response_partial_update_product import (
    ResponsePartialUpdateProduct,
)
from eazyrent.products.v1.models.response_update_product import ResponseUpdateProduct
from eazyrent.products.v1.models.update_product import UpdateProduct

from eazyrent.products.v1.api_client import ApiClient, RequestSerialized
from eazyrent.products.v1.api_response import ApiResponse
from eazyrent.products.v1.rest import RESTResponseType


class ProductApi:
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    def __init__(self, api_client=None) -> None:
        if api_client is None:
            api_client = ApiClient.get_default()
        self.api_client = api_client

    @validate_call
    def create_product(
        self,
        product: Product,
        x_eaz_account_id: Annotated[
            Optional[StrictStr],
            Field(
                description="The default is always the organization of the requesting user. If you like to get/set a result of another organization include the header. Make sure the user has permission to access the requested data."
            ),
        ] = 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,
    ) -> ResponseCreateProduct:
        """Create product

        ## 🔒 Authentication  This endpoint require a valid OAuth2 Bearer  It supports account impersonation within Organization's sub-accounts using `X-Eaz-Account-Id` Header.  - If the `X-Eaz-Account-Id` header is provided and the user has access rights to that sub-account, the impersonation context is applied. - Otherwise, the user's own account context is used. ### Scopes :  User must provide one of the following scopes: - `admin` - `staff` - `user` - `org:admin` - `org:staff` - `org:user` - `products:write`

        :param product: (required)
        :type product: Product
        :param x_eaz_account_id: The default is always the organization of the requesting user. If you like to get/set a result of another organization include the header. Make sure the user has permission to access the requested data.
        :type x_eaz_account_id: str
        :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._create_product_serialize(
            product=product,
            x_eaz_account_id=x_eaz_account_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

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

    @validate_call
    def create_product_with_http_info(
        self,
        product: Product,
        x_eaz_account_id: Annotated[
            Optional[StrictStr],
            Field(
                description="The default is always the organization of the requesting user. If you like to get/set a result of another organization include the header. Make sure the user has permission to access the requested data."
            ),
        ] = 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[ResponseCreateProduct]:
        """Create product

        ## 🔒 Authentication  This endpoint require a valid OAuth2 Bearer  It supports account impersonation within Organization's sub-accounts using `X-Eaz-Account-Id` Header.  - If the `X-Eaz-Account-Id` header is provided and the user has access rights to that sub-account, the impersonation context is applied. - Otherwise, the user's own account context is used. ### Scopes :  User must provide one of the following scopes: - `admin` - `staff` - `user` - `org:admin` - `org:staff` - `org:user` - `products:write`

        :param product: (required)
        :type product: Product
        :param x_eaz_account_id: The default is always the organization of the requesting user. If you like to get/set a result of another organization include the header. Make sure the user has permission to access the requested data.
        :type x_eaz_account_id: str
        :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._create_product_serialize(
            product=product,
            x_eaz_account_id=x_eaz_account_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

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

    @validate_call
    def create_product_without_preload_content(
        self,
        product: Product,
        x_eaz_account_id: Annotated[
            Optional[StrictStr],
            Field(
                description="The default is always the organization of the requesting user. If you like to get/set a result of another organization include the header. Make sure the user has permission to access the requested data."
            ),
        ] = 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:
        """Create product

        ## 🔒 Authentication  This endpoint require a valid OAuth2 Bearer  It supports account impersonation within Organization's sub-accounts using `X-Eaz-Account-Id` Header.  - If the `X-Eaz-Account-Id` header is provided and the user has access rights to that sub-account, the impersonation context is applied. - Otherwise, the user's own account context is used. ### Scopes :  User must provide one of the following scopes: - `admin` - `staff` - `user` - `org:admin` - `org:staff` - `org:user` - `products:write`

        :param product: (required)
        :type product: Product
        :param x_eaz_account_id: The default is always the organization of the requesting user. If you like to get/set a result of another organization include the header. Make sure the user has permission to access the requested data.
        :type x_eaz_account_id: str
        :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._create_product_serialize(
            product=product,
            x_eaz_account_id=x_eaz_account_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

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

    def _create_product_serialize(
        self,
        product,
        x_eaz_account_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {}

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        if x_eaz_account_id is not None:
            _header_params["x-eaz-account-id"] = x_eaz_account_id
        # process the form parameters
        # process the body parameter
        if product is not None:
            _body_params = product

        # set the HTTP header `Accept`
        if "Accept" not in _header_params:
            _header_params["Accept"] = self.api_client.select_header_accept(
                ["application/json"]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params["Content-Type"] = _content_type
        else:
            _default_content_type = self.api_client.select_header_content_type(
                ["application/json"]
            )
            if _default_content_type is not None:
                _header_params["Content-Type"] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = ["APIKeyHeader", "OAuth2"]

        return self.api_client.param_serialize(
            method="POST",
            resource_path="/products/",
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth,
        )

    @validate_call
    def delete_product(
        self,
        id: StrictStr,
        cascade: Optional[StrictBool] = None,
        x_eaz_account_id: Annotated[
            Optional[StrictStr],
            Field(
                description="The default is always the organization of the requesting user. If you like to get/set a result of another organization include the header. Make sure the user has permission to access the requested data."
            ),
        ] = 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,
    ) -> None:
        """Delete product

        ## 🔒 Authentication  This endpoint require a valid OAuth2 Bearer  It supports account impersonation within Organization's sub-accounts using `X-Eaz-Account-Id` Header.  - If the `X-Eaz-Account-Id` header is provided and the user has access rights to that sub-account, the impersonation context is applied. - Otherwise, the user's own account context is used. ### Scopes :  User must provide one of the following scopes: - `admin` - `staff` - `user` - `org:admin` - `org:staff` - `org:user` - `products:write`

        :param id: (required)
        :type id: str
        :param cascade:
        :type cascade: bool
        :param x_eaz_account_id: The default is always the organization of the requesting user. If you like to get/set a result of another organization include the header. Make sure the user has permission to access the requested data.
        :type x_eaz_account_id: str
        :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._delete_product_serialize(
            id=id,
            cascade=cascade,
            x_eaz_account_id=x_eaz_account_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

        _response_types_map: Dict[str, Optional[str]] = {
            "204": None,
            "422": "HTTPValidationError",
        }
        response_data = self.api_client.call_api(
            *_param, _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data

    @validate_call
    def delete_product_with_http_info(
        self,
        id: StrictStr,
        cascade: Optional[StrictBool] = None,
        x_eaz_account_id: Annotated[
            Optional[StrictStr],
            Field(
                description="The default is always the organization of the requesting user. If you like to get/set a result of another organization include the header. Make sure the user has permission to access the requested data."
            ),
        ] = 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[None]:
        """Delete product

        ## 🔒 Authentication  This endpoint require a valid OAuth2 Bearer  It supports account impersonation within Organization's sub-accounts using `X-Eaz-Account-Id` Header.  - If the `X-Eaz-Account-Id` header is provided and the user has access rights to that sub-account, the impersonation context is applied. - Otherwise, the user's own account context is used. ### Scopes :  User must provide one of the following scopes: - `admin` - `staff` - `user` - `org:admin` - `org:staff` - `org:user` - `products:write`

        :param id: (required)
        :type id: str
        :param cascade:
        :type cascade: bool
        :param x_eaz_account_id: The default is always the organization of the requesting user. If you like to get/set a result of another organization include the header. Make sure the user has permission to access the requested data.
        :type x_eaz_account_id: str
        :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._delete_product_serialize(
            id=id,
            cascade=cascade,
            x_eaz_account_id=x_eaz_account_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

        _response_types_map: Dict[str, Optional[str]] = {
            "204": None,
            "422": "HTTPValidationError",
        }
        response_data = self.api_client.call_api(
            *_param, _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )

    @validate_call
    def delete_product_without_preload_content(
        self,
        id: StrictStr,
        cascade: Optional[StrictBool] = None,
        x_eaz_account_id: Annotated[
            Optional[StrictStr],
            Field(
                description="The default is always the organization of the requesting user. If you like to get/set a result of another organization include the header. Make sure the user has permission to access the requested data."
            ),
        ] = 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:
        """Delete product

        ## 🔒 Authentication  This endpoint require a valid OAuth2 Bearer  It supports account impersonation within Organization's sub-accounts using `X-Eaz-Account-Id` Header.  - If the `X-Eaz-Account-Id` header is provided and the user has access rights to that sub-account, the impersonation context is applied. - Otherwise, the user's own account context is used. ### Scopes :  User must provide one of the following scopes: - `admin` - `staff` - `user` - `org:admin` - `org:staff` - `org:user` - `products:write`

        :param id: (required)
        :type id: str
        :param cascade:
        :type cascade: bool
        :param x_eaz_account_id: The default is always the organization of the requesting user. If you like to get/set a result of another organization include the header. Make sure the user has permission to access the requested data.
        :type x_eaz_account_id: str
        :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._delete_product_serialize(
            id=id,
            cascade=cascade,
            x_eaz_account_id=x_eaz_account_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

        _response_types_map: Dict[str, Optional[str]] = {
            "204": None,
            "422": "HTTPValidationError",
        }
        response_data = self.api_client.call_api(
            *_param, _request_timeout=_request_timeout
        )
        return response_data.response

    def _delete_product_serialize(
        self,
        id,
        cascade,
        x_eaz_account_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {}

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if id is not None:
            _path_params["id"] = id
        # process the query parameters
        if cascade is not None:

            _query_params.append(("cascade", cascade))

        # process the header parameters
        if x_eaz_account_id is not None:
            _header_params["x-eaz-account-id"] = x_eaz_account_id
        # process the form parameters
        # process the body parameter

        # set the HTTP header `Accept`
        if "Accept" not in _header_params:
            _header_params["Accept"] = self.api_client.select_header_accept(
                ["application/json"]
            )

        # authentication setting
        _auth_settings: List[str] = ["APIKeyHeader", "OAuth2"]

        return self.api_client.param_serialize(
            method="DELETE",
            resource_path="/products/{id}/",
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth,
        )

    @validate_call
    def get_product(
        self,
        id: StrictStr,
        x_eaz_account_id: Annotated[
            Optional[StrictStr],
            Field(
                description="The default is always the organization of the requesting user. If you like to get/set a result of another organization include the header. Make sure the user has permission to access the requested data."
            ),
        ] = 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,
    ) -> ResponseGetProduct:
        """Get product

        Detail  ## 🔒 Authentication  This endpoint require a valid OAuth2 Bearer  It supports account impersonation within Organization's sub-accounts using `X-Eaz-Account-Id` Header.  - If the `X-Eaz-Account-Id` header is provided and the user has access rights to that sub-account, the impersonation context is applied. - Otherwise, the user's own account context is used. ### Scopes :  User must provide one of the following scopes: - `admin` - `staff` - `user` - `org:admin` - `org:staff` - `org:user` - `products:read`

        :param id: (required)
        :type id: str
        :param x_eaz_account_id: The default is always the organization of the requesting user. If you like to get/set a result of another organization include the header. Make sure the user has permission to access the requested data.
        :type x_eaz_account_id: str
        :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_product_serialize(
            id=id,
            x_eaz_account_id=x_eaz_account_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

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

    @validate_call
    def get_product_with_http_info(
        self,
        id: StrictStr,
        x_eaz_account_id: Annotated[
            Optional[StrictStr],
            Field(
                description="The default is always the organization of the requesting user. If you like to get/set a result of another organization include the header. Make sure the user has permission to access the requested data."
            ),
        ] = 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[ResponseGetProduct]:
        """Get product

        Detail  ## 🔒 Authentication  This endpoint require a valid OAuth2 Bearer  It supports account impersonation within Organization's sub-accounts using `X-Eaz-Account-Id` Header.  - If the `X-Eaz-Account-Id` header is provided and the user has access rights to that sub-account, the impersonation context is applied. - Otherwise, the user's own account context is used. ### Scopes :  User must provide one of the following scopes: - `admin` - `staff` - `user` - `org:admin` - `org:staff` - `org:user` - `products:read`

        :param id: (required)
        :type id: str
        :param x_eaz_account_id: The default is always the organization of the requesting user. If you like to get/set a result of another organization include the header. Make sure the user has permission to access the requested data.
        :type x_eaz_account_id: str
        :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_product_serialize(
            id=id,
            x_eaz_account_id=x_eaz_account_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

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

    @validate_call
    def get_product_without_preload_content(
        self,
        id: StrictStr,
        x_eaz_account_id: Annotated[
            Optional[StrictStr],
            Field(
                description="The default is always the organization of the requesting user. If you like to get/set a result of another organization include the header. Make sure the user has permission to access the requested data."
            ),
        ] = 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:
        """Get product

        Detail  ## 🔒 Authentication  This endpoint require a valid OAuth2 Bearer  It supports account impersonation within Organization's sub-accounts using `X-Eaz-Account-Id` Header.  - If the `X-Eaz-Account-Id` header is provided and the user has access rights to that sub-account, the impersonation context is applied. - Otherwise, the user's own account context is used. ### Scopes :  User must provide one of the following scopes: - `admin` - `staff` - `user` - `org:admin` - `org:staff` - `org:user` - `products:read`

        :param id: (required)
        :type id: str
        :param x_eaz_account_id: The default is always the organization of the requesting user. If you like to get/set a result of another organization include the header. Make sure the user has permission to access the requested data.
        :type x_eaz_account_id: str
        :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_product_serialize(
            id=id,
            x_eaz_account_id=x_eaz_account_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

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

    def _get_product_serialize(
        self,
        id,
        x_eaz_account_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {}

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if id is not None:
            _path_params["id"] = id
        # process the query parameters
        # process the header parameters
        if x_eaz_account_id is not None:
            _header_params["x-eaz-account-id"] = x_eaz_account_id
        # process the form parameters
        # process the body parameter

        # set the HTTP header `Accept`
        if "Accept" not in _header_params:
            _header_params["Accept"] = self.api_client.select_header_accept(
                ["application/json"]
            )

        # authentication setting
        _auth_settings: List[str] = ["APIKeyHeader", "OAuth2"]

        return self.api_client.param_serialize(
            method="GET",
            resource_path="/products/{id}/",
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth,
        )

    @validate_call
    def list_products(
        self,
        order_by: Optional[StrictStr] = None,
        limit: Optional[Annotated[int, Field(le=100, strict=True, ge=1)]] = None,
        offset: Optional[Annotated[int, Field(strict=True, ge=0)]] = None,
        search: Optional[StrictStr] = None,
        category: Optional[ProductType] = None,
        managers__in: Optional[StrictStr] = None,
        managers__nin: Optional[StrictStr] = None,
        managers__eq: Optional[Any] = None,
        available: Optional[StrictBool] = None,
        mandate_type: Optional[MandateType] = None,
        created_at__lte: Optional[datetime] = None,
        created_at__gte: Optional[datetime] = None,
        updated_at__lte: Optional[datetime] = None,
        updated_at__gte: Optional[datetime] = None,
        price__gte: Optional[Union[StrictFloat, StrictInt]] = None,
        price__lte: Optional[Union[StrictFloat, StrictInt]] = None,
        archived__lte: Optional[datetime] = None,
        archived__gte: Optional[datetime] = None,
        x_eaz_account_id: Annotated[
            Optional[StrictStr],
            Field(
                description="The default is always the organization of the requesting user. If you like to get/set a result of another organization include the header. Make sure the user has permission to access the requested data."
            ),
        ] = 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,
    ) -> PaginatedResponseUnionListForRentProductListForSalesProduct:
        """List products

        ## 🔒 Authentication  This endpoint require a valid OAuth2 Bearer  It supports account impersonation within Organization's sub-accounts using `X-Eaz-Account-Id` Header.  - If the `X-Eaz-Account-Id` header is provided and the user has access rights to that sub-account, the impersonation context is applied. - Otherwise, the user's own account context is used. ### Scopes :  User must provide one of the following scopes: - `admin` - `staff` - `user` - `org:admin` - `org:staff` - `org:user` - `products:read`  ## 📄 Pagination  This endpoint uses pagination with `limit` and `offset`.

        :param order_by:
        :type order_by: str
        :param limit:
        :type limit: int
        :param offset:
        :type offset: int
        :param search:
        :type search: str
        :param category:
        :type category: ProductType
        :param managers__in:
        :type managers__in: str
        :param managers__nin:
        :type managers__nin: str
        :param managers__eq:
        :type managers__eq: ManagersEq
        :param available:
        :type available: bool
        :param mandate_type:
        :type mandate_type: MandateType
        :param created_at__lte:
        :type created_at__lte: datetime
        :param created_at__gte:
        :type created_at__gte: datetime
        :param updated_at__lte:
        :type updated_at__lte: datetime
        :param updated_at__gte:
        :type updated_at__gte: datetime
        :param price__gte:
        :type price__gte: float
        :param price__lte:
        :type price__lte: float
        :param archived__lte:
        :type archived__lte: datetime
        :param archived__gte:
        :type archived__gte: datetime
        :param x_eaz_account_id: The default is always the organization of the requesting user. If you like to get/set a result of another organization include the header. Make sure the user has permission to access the requested data.
        :type x_eaz_account_id: str
        :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._list_products_serialize(
            order_by=order_by,
            limit=limit,
            offset=offset,
            search=search,
            category=category,
            managers__in=managers__in,
            managers__nin=managers__nin,
            managers__eq=managers__eq,
            available=available,
            mandate_type=mandate_type,
            created_at__lte=created_at__lte,
            created_at__gte=created_at__gte,
            updated_at__lte=updated_at__lte,
            updated_at__gte=updated_at__gte,
            price__gte=price__gte,
            price__lte=price__lte,
            archived__lte=archived__lte,
            archived__gte=archived__gte,
            x_eaz_account_id=x_eaz_account_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

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

    @validate_call
    def list_products_with_http_info(
        self,
        order_by: Optional[StrictStr] = None,
        limit: Optional[Annotated[int, Field(le=100, strict=True, ge=1)]] = None,
        offset: Optional[Annotated[int, Field(strict=True, ge=0)]] = None,
        search: Optional[StrictStr] = None,
        category: Optional[ProductType] = None,
        managers__in: Optional[StrictStr] = None,
        managers__nin: Optional[StrictStr] = None,
        managers__eq: Optional[Any] = None,
        available: Optional[StrictBool] = None,
        mandate_type: Optional[MandateType] = None,
        created_at__lte: Optional[datetime] = None,
        created_at__gte: Optional[datetime] = None,
        updated_at__lte: Optional[datetime] = None,
        updated_at__gte: Optional[datetime] = None,
        price__gte: Optional[Union[StrictFloat, StrictInt]] = None,
        price__lte: Optional[Union[StrictFloat, StrictInt]] = None,
        archived__lte: Optional[datetime] = None,
        archived__gte: Optional[datetime] = None,
        x_eaz_account_id: Annotated[
            Optional[StrictStr],
            Field(
                description="The default is always the organization of the requesting user. If you like to get/set a result of another organization include the header. Make sure the user has permission to access the requested data."
            ),
        ] = 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[PaginatedResponseUnionListForRentProductListForSalesProduct]:
        """List products

        ## 🔒 Authentication  This endpoint require a valid OAuth2 Bearer  It supports account impersonation within Organization's sub-accounts using `X-Eaz-Account-Id` Header.  - If the `X-Eaz-Account-Id` header is provided and the user has access rights to that sub-account, the impersonation context is applied. - Otherwise, the user's own account context is used. ### Scopes :  User must provide one of the following scopes: - `admin` - `staff` - `user` - `org:admin` - `org:staff` - `org:user` - `products:read`  ## 📄 Pagination  This endpoint uses pagination with `limit` and `offset`.

        :param order_by:
        :type order_by: str
        :param limit:
        :type limit: int
        :param offset:
        :type offset: int
        :param search:
        :type search: str
        :param category:
        :type category: ProductType
        :param managers__in:
        :type managers__in: str
        :param managers__nin:
        :type managers__nin: str
        :param managers__eq:
        :type managers__eq: ManagersEq
        :param available:
        :type available: bool
        :param mandate_type:
        :type mandate_type: MandateType
        :param created_at__lte:
        :type created_at__lte: datetime
        :param created_at__gte:
        :type created_at__gte: datetime
        :param updated_at__lte:
        :type updated_at__lte: datetime
        :param updated_at__gte:
        :type updated_at__gte: datetime
        :param price__gte:
        :type price__gte: float
        :param price__lte:
        :type price__lte: float
        :param archived__lte:
        :type archived__lte: datetime
        :param archived__gte:
        :type archived__gte: datetime
        :param x_eaz_account_id: The default is always the organization of the requesting user. If you like to get/set a result of another organization include the header. Make sure the user has permission to access the requested data.
        :type x_eaz_account_id: str
        :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._list_products_serialize(
            order_by=order_by,
            limit=limit,
            offset=offset,
            search=search,
            category=category,
            managers__in=managers__in,
            managers__nin=managers__nin,
            managers__eq=managers__eq,
            available=available,
            mandate_type=mandate_type,
            created_at__lte=created_at__lte,
            created_at__gte=created_at__gte,
            updated_at__lte=updated_at__lte,
            updated_at__gte=updated_at__gte,
            price__gte=price__gte,
            price__lte=price__lte,
            archived__lte=archived__lte,
            archived__gte=archived__gte,
            x_eaz_account_id=x_eaz_account_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

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

    @validate_call
    def list_products_without_preload_content(
        self,
        order_by: Optional[StrictStr] = None,
        limit: Optional[Annotated[int, Field(le=100, strict=True, ge=1)]] = None,
        offset: Optional[Annotated[int, Field(strict=True, ge=0)]] = None,
        search: Optional[StrictStr] = None,
        category: Optional[ProductType] = None,
        managers__in: Optional[StrictStr] = None,
        managers__nin: Optional[StrictStr] = None,
        managers__eq: Optional[Any] = None,
        available: Optional[StrictBool] = None,
        mandate_type: Optional[MandateType] = None,
        created_at__lte: Optional[datetime] = None,
        created_at__gte: Optional[datetime] = None,
        updated_at__lte: Optional[datetime] = None,
        updated_at__gte: Optional[datetime] = None,
        price__gte: Optional[Union[StrictFloat, StrictInt]] = None,
        price__lte: Optional[Union[StrictFloat, StrictInt]] = None,
        archived__lte: Optional[datetime] = None,
        archived__gte: Optional[datetime] = None,
        x_eaz_account_id: Annotated[
            Optional[StrictStr],
            Field(
                description="The default is always the organization of the requesting user. If you like to get/set a result of another organization include the header. Make sure the user has permission to access the requested data."
            ),
        ] = 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:
        """List products

        ## 🔒 Authentication  This endpoint require a valid OAuth2 Bearer  It supports account impersonation within Organization's sub-accounts using `X-Eaz-Account-Id` Header.  - If the `X-Eaz-Account-Id` header is provided and the user has access rights to that sub-account, the impersonation context is applied. - Otherwise, the user's own account context is used. ### Scopes :  User must provide one of the following scopes: - `admin` - `staff` - `user` - `org:admin` - `org:staff` - `org:user` - `products:read`  ## 📄 Pagination  This endpoint uses pagination with `limit` and `offset`.

        :param order_by:
        :type order_by: str
        :param limit:
        :type limit: int
        :param offset:
        :type offset: int
        :param search:
        :type search: str
        :param category:
        :type category: ProductType
        :param managers__in:
        :type managers__in: str
        :param managers__nin:
        :type managers__nin: str
        :param managers__eq:
        :type managers__eq: ManagersEq
        :param available:
        :type available: bool
        :param mandate_type:
        :type mandate_type: MandateType
        :param created_at__lte:
        :type created_at__lte: datetime
        :param created_at__gte:
        :type created_at__gte: datetime
        :param updated_at__lte:
        :type updated_at__lte: datetime
        :param updated_at__gte:
        :type updated_at__gte: datetime
        :param price__gte:
        :type price__gte: float
        :param price__lte:
        :type price__lte: float
        :param archived__lte:
        :type archived__lte: datetime
        :param archived__gte:
        :type archived__gte: datetime
        :param x_eaz_account_id: The default is always the organization of the requesting user. If you like to get/set a result of another organization include the header. Make sure the user has permission to access the requested data.
        :type x_eaz_account_id: str
        :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._list_products_serialize(
            order_by=order_by,
            limit=limit,
            offset=offset,
            search=search,
            category=category,
            managers__in=managers__in,
            managers__nin=managers__nin,
            managers__eq=managers__eq,
            available=available,
            mandate_type=mandate_type,
            created_at__lte=created_at__lte,
            created_at__gte=created_at__gte,
            updated_at__lte=updated_at__lte,
            updated_at__gte=updated_at__gte,
            price__gte=price__gte,
            price__lte=price__lte,
            archived__lte=archived__lte,
            archived__gte=archived__gte,
            x_eaz_account_id=x_eaz_account_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

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

    def _list_products_serialize(
        self,
        order_by,
        limit,
        offset,
        search,
        category,
        managers__in,
        managers__nin,
        managers__eq,
        available,
        mandate_type,
        created_at__lte,
        created_at__gte,
        updated_at__lte,
        updated_at__gte,
        price__gte,
        price__lte,
        archived__lte,
        archived__gte,
        x_eaz_account_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {}

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        if order_by is not None:

            _query_params.append(("order_by", order_by))

        if limit is not None:

            _query_params.append(("limit", limit))

        if offset is not None:

            _query_params.append(("offset", offset))

        if search is not None:

            _query_params.append(("search", search))

        if category is not None:

            _query_params.append(("category", category.value))

        if managers__in is not None:

            _query_params.append(("managers__in", managers__in))

        if managers__nin is not None:

            _query_params.append(("managers__nin", managers__nin))

        if managers__eq is not None:

            _query_params.append(("managers__eq", managers__eq))

        if available is not None:

            _query_params.append(("available", available))

        if mandate_type is not None:

            _query_params.append(("mandate_type", mandate_type.value))

        if created_at__lte is not None:
            if isinstance(created_at__lte, datetime):
                _query_params.append(
                    (
                        "created_at__lte",
                        created_at__lte.strftime(
                            self.api_client.configuration.datetime_format
                        ),
                    )
                )
            else:
                _query_params.append(("created_at__lte", created_at__lte))

        if created_at__gte is not None:
            if isinstance(created_at__gte, datetime):
                _query_params.append(
                    (
                        "created_at__gte",
                        created_at__gte.strftime(
                            self.api_client.configuration.datetime_format
                        ),
                    )
                )
            else:
                _query_params.append(("created_at__gte", created_at__gte))

        if updated_at__lte is not None:
            if isinstance(updated_at__lte, datetime):
                _query_params.append(
                    (
                        "updated_at__lte",
                        updated_at__lte.strftime(
                            self.api_client.configuration.datetime_format
                        ),
                    )
                )
            else:
                _query_params.append(("updated_at__lte", updated_at__lte))

        if updated_at__gte is not None:
            if isinstance(updated_at__gte, datetime):
                _query_params.append(
                    (
                        "updated_at__gte",
                        updated_at__gte.strftime(
                            self.api_client.configuration.datetime_format
                        ),
                    )
                )
            else:
                _query_params.append(("updated_at__gte", updated_at__gte))

        if price__gte is not None:

            _query_params.append(("price__gte", price__gte))

        if price__lte is not None:

            _query_params.append(("price__lte", price__lte))

        if archived__lte is not None:
            if isinstance(archived__lte, datetime):
                _query_params.append(
                    (
                        "archived__lte",
                        archived__lte.strftime(
                            self.api_client.configuration.datetime_format
                        ),
                    )
                )
            else:
                _query_params.append(("archived__lte", archived__lte))

        if archived__gte is not None:
            if isinstance(archived__gte, datetime):
                _query_params.append(
                    (
                        "archived__gte",
                        archived__gte.strftime(
                            self.api_client.configuration.datetime_format
                        ),
                    )
                )
            else:
                _query_params.append(("archived__gte", archived__gte))

        # process the header parameters
        if x_eaz_account_id is not None:
            _header_params["x-eaz-account-id"] = x_eaz_account_id
        # process the form parameters
        # process the body parameter

        # set the HTTP header `Accept`
        if "Accept" not in _header_params:
            _header_params["Accept"] = self.api_client.select_header_accept(
                ["application/json"]
            )

        # authentication setting
        _auth_settings: List[str] = ["APIKeyHeader", "OAuth2"]

        return self.api_client.param_serialize(
            method="GET",
            resource_path="/products/",
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth,
        )

    @validate_call
    def partial_update_product(
        self,
        id: StrictStr,
        update_product: UpdateProduct,
        x_eaz_account_id: Annotated[
            Optional[StrictStr],
            Field(
                description="The default is always the organization of the requesting user. If you like to get/set a result of another organization include the header. Make sure the user has permission to access the requested data."
            ),
        ] = 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,
    ) -> ResponsePartialUpdateProduct:
        """Partial update product

        ## 🔒 Authentication  This endpoint require a valid OAuth2 Bearer  It supports account impersonation within Organization's sub-accounts using `X-Eaz-Account-Id` Header.  - If the `X-Eaz-Account-Id` header is provided and the user has access rights to that sub-account, the impersonation context is applied. - Otherwise, the user's own account context is used. ### Scopes :  User must provide one of the following scopes: - `admin` - `staff` - `user` - `org:admin` - `org:staff` - `org:user` - `products:write`

        :param id: (required)
        :type id: str
        :param update_product: (required)
        :type update_product: UpdateProduct
        :param x_eaz_account_id: The default is always the organization of the requesting user. If you like to get/set a result of another organization include the header. Make sure the user has permission to access the requested data.
        :type x_eaz_account_id: str
        :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._partial_update_product_serialize(
            id=id,
            update_product=update_product,
            x_eaz_account_id=x_eaz_account_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

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

    @validate_call
    def partial_update_product_with_http_info(
        self,
        id: StrictStr,
        update_product: UpdateProduct,
        x_eaz_account_id: Annotated[
            Optional[StrictStr],
            Field(
                description="The default is always the organization of the requesting user. If you like to get/set a result of another organization include the header. Make sure the user has permission to access the requested data."
            ),
        ] = 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[ResponsePartialUpdateProduct]:
        """Partial update product

        ## 🔒 Authentication  This endpoint require a valid OAuth2 Bearer  It supports account impersonation within Organization's sub-accounts using `X-Eaz-Account-Id` Header.  - If the `X-Eaz-Account-Id` header is provided and the user has access rights to that sub-account, the impersonation context is applied. - Otherwise, the user's own account context is used. ### Scopes :  User must provide one of the following scopes: - `admin` - `staff` - `user` - `org:admin` - `org:staff` - `org:user` - `products:write`

        :param id: (required)
        :type id: str
        :param update_product: (required)
        :type update_product: UpdateProduct
        :param x_eaz_account_id: The default is always the organization of the requesting user. If you like to get/set a result of another organization include the header. Make sure the user has permission to access the requested data.
        :type x_eaz_account_id: str
        :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._partial_update_product_serialize(
            id=id,
            update_product=update_product,
            x_eaz_account_id=x_eaz_account_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

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

    @validate_call
    def partial_update_product_without_preload_content(
        self,
        id: StrictStr,
        update_product: UpdateProduct,
        x_eaz_account_id: Annotated[
            Optional[StrictStr],
            Field(
                description="The default is always the organization of the requesting user. If you like to get/set a result of another organization include the header. Make sure the user has permission to access the requested data."
            ),
        ] = 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:
        """Partial update product

        ## 🔒 Authentication  This endpoint require a valid OAuth2 Bearer  It supports account impersonation within Organization's sub-accounts using `X-Eaz-Account-Id` Header.  - If the `X-Eaz-Account-Id` header is provided and the user has access rights to that sub-account, the impersonation context is applied. - Otherwise, the user's own account context is used. ### Scopes :  User must provide one of the following scopes: - `admin` - `staff` - `user` - `org:admin` - `org:staff` - `org:user` - `products:write`

        :param id: (required)
        :type id: str
        :param update_product: (required)
        :type update_product: UpdateProduct
        :param x_eaz_account_id: The default is always the organization of the requesting user. If you like to get/set a result of another organization include the header. Make sure the user has permission to access the requested data.
        :type x_eaz_account_id: str
        :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._partial_update_product_serialize(
            id=id,
            update_product=update_product,
            x_eaz_account_id=x_eaz_account_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

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

    def _partial_update_product_serialize(
        self,
        id,
        update_product,
        x_eaz_account_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {}

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if id is not None:
            _path_params["id"] = id
        # process the query parameters
        # process the header parameters
        if x_eaz_account_id is not None:
            _header_params["x-eaz-account-id"] = x_eaz_account_id
        # process the form parameters
        # process the body parameter
        if update_product is not None:
            _body_params = update_product

        # set the HTTP header `Accept`
        if "Accept" not in _header_params:
            _header_params["Accept"] = self.api_client.select_header_accept(
                ["application/json"]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params["Content-Type"] = _content_type
        else:
            _default_content_type = self.api_client.select_header_content_type(
                ["application/json"]
            )
            if _default_content_type is not None:
                _header_params["Content-Type"] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = ["APIKeyHeader", "OAuth2"]

        return self.api_client.param_serialize(
            method="PATCH",
            resource_path="/products/{id}/",
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth,
        )

    @validate_call
    def update_product(
        self,
        id: StrictStr,
        update_product: UpdateProduct,
        x_eaz_account_id: Annotated[
            Optional[StrictStr],
            Field(
                description="The default is always the organization of the requesting user. If you like to get/set a result of another organization include the header. Make sure the user has permission to access the requested data."
            ),
        ] = 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,
    ) -> ResponseUpdateProduct:
        """Update product

        ## 🔒 Authentication  This endpoint require a valid OAuth2 Bearer  It supports account impersonation within Organization's sub-accounts using `X-Eaz-Account-Id` Header.  - If the `X-Eaz-Account-Id` header is provided and the user has access rights to that sub-account, the impersonation context is applied. - Otherwise, the user's own account context is used. ### Scopes :  User must provide one of the following scopes: - `admin` - `staff` - `user` - `org:admin` - `org:staff` - `org:user` - `products:write`

        :param id: (required)
        :type id: str
        :param update_product: (required)
        :type update_product: UpdateProduct
        :param x_eaz_account_id: The default is always the organization of the requesting user. If you like to get/set a result of another organization include the header. Make sure the user has permission to access the requested data.
        :type x_eaz_account_id: str
        :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._update_product_serialize(
            id=id,
            update_product=update_product,
            x_eaz_account_id=x_eaz_account_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

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

    @validate_call
    def update_product_with_http_info(
        self,
        id: StrictStr,
        update_product: UpdateProduct,
        x_eaz_account_id: Annotated[
            Optional[StrictStr],
            Field(
                description="The default is always the organization of the requesting user. If you like to get/set a result of another organization include the header. Make sure the user has permission to access the requested data."
            ),
        ] = 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[ResponseUpdateProduct]:
        """Update product

        ## 🔒 Authentication  This endpoint require a valid OAuth2 Bearer  It supports account impersonation within Organization's sub-accounts using `X-Eaz-Account-Id` Header.  - If the `X-Eaz-Account-Id` header is provided and the user has access rights to that sub-account, the impersonation context is applied. - Otherwise, the user's own account context is used. ### Scopes :  User must provide one of the following scopes: - `admin` - `staff` - `user` - `org:admin` - `org:staff` - `org:user` - `products:write`

        :param id: (required)
        :type id: str
        :param update_product: (required)
        :type update_product: UpdateProduct
        :param x_eaz_account_id: The default is always the organization of the requesting user. If you like to get/set a result of another organization include the header. Make sure the user has permission to access the requested data.
        :type x_eaz_account_id: str
        :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._update_product_serialize(
            id=id,
            update_product=update_product,
            x_eaz_account_id=x_eaz_account_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

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

    @validate_call
    def update_product_without_preload_content(
        self,
        id: StrictStr,
        update_product: UpdateProduct,
        x_eaz_account_id: Annotated[
            Optional[StrictStr],
            Field(
                description="The default is always the organization of the requesting user. If you like to get/set a result of another organization include the header. Make sure the user has permission to access the requested data."
            ),
        ] = 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:
        """Update product

        ## 🔒 Authentication  This endpoint require a valid OAuth2 Bearer  It supports account impersonation within Organization's sub-accounts using `X-Eaz-Account-Id` Header.  - If the `X-Eaz-Account-Id` header is provided and the user has access rights to that sub-account, the impersonation context is applied. - Otherwise, the user's own account context is used. ### Scopes :  User must provide one of the following scopes: - `admin` - `staff` - `user` - `org:admin` - `org:staff` - `org:user` - `products:write`

        :param id: (required)
        :type id: str
        :param update_product: (required)
        :type update_product: UpdateProduct
        :param x_eaz_account_id: The default is always the organization of the requesting user. If you like to get/set a result of another organization include the header. Make sure the user has permission to access the requested data.
        :type x_eaz_account_id: str
        :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._update_product_serialize(
            id=id,
            update_product=update_product,
            x_eaz_account_id=x_eaz_account_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

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

    def _update_product_serialize(
        self,
        id,
        update_product,
        x_eaz_account_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {}

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if id is not None:
            _path_params["id"] = id
        # process the query parameters
        # process the header parameters
        if x_eaz_account_id is not None:
            _header_params["x-eaz-account-id"] = x_eaz_account_id
        # process the form parameters
        # process the body parameter
        if update_product is not None:
            _body_params = update_product

        # set the HTTP header `Accept`
        if "Accept" not in _header_params:
            _header_params["Accept"] = self.api_client.select_header_accept(
                ["application/json"]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params["Content-Type"] = _content_type
        else:
            _default_content_type = self.api_client.select_header_content_type(
                ["application/json"]
            )
            if _default_content_type is not None:
                _header_params["Content-Type"] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = ["APIKeyHeader", "OAuth2"]

        return self.api_client.param_serialize(
            method="PUT",
            resource_path="/products/{id}/",
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth,
        )
