ghl-sdk 0.5.1

// @generated by xtask/generate_services.py — do not edit by hand.
//! `products` — typed methods for all 27 API v2 operations
//! in this module.
//!
//! Access via [`Ghl::products`](crate::Ghl::products).
//!
//! Request and response types come from [`ghl_models::v2::products`](https://docs.rs/ghl-models/latest/ghl_models/v2/products/); every endpoint is also documented in the
//! [`products` API reference](https://github.com/Shahroz/ghl-rs/blob/main/docs/api/products.md).
//!
//! Enable with `features = ["products"]`.

#![allow(clippy::too_many_arguments)]

use crate::client::Ghl;
use crate::error::Result;
use ghl_models::v2::products as models;

/// Typed access to the `products` API v2 surface (27 operations). Obtained via
/// [`Ghl::products`](crate::Ghl::products).
#[derive(Debug, Clone)]
pub struct ProductsService {
    pub(crate) client: Ghl,
}

impl ProductsService {
    pub(crate) fn new(client: Ghl) -> Self {
        Self { client }
    }
}

/// Query parameters for [`ProductsService::list_products`].
#[derive(Debug, Clone, Default)]
pub struct ListProductsParams {
    /// The maximum number of items to be included in a single page of results
    pub limit: Option<f64>,
    /// The starting index of the page, indicating the position from which the results
    /// should be retrieved.
    pub offset: Option<f64>,
    /// LocationId is the id of the sub-account
    /// Required by the API.
    pub location_id: String,
    /// The name of the product for searching.
    pub search: Option<String>,
    /// Filter by product category Ids. Supports comma separated values
    pub collection_ids: Option<String>,
    /// The slug value of the collection by which the collection would be searched
    pub collection_slug: Option<String>,
    /// Name of an entity whose data has to be fetched along with product. Possible entities
    /// are tax, stripe and paypal. If not mentioned, only ID will be returned in case of
    /// taxes
    pub expand: Option<String>,
    /// List of product ids to be fetched.
    pub product_ids: Option<String>,
    /// fetch and project products based on the storeId
    pub store_id: Option<String>,
    /// Separate products by which are included in the store and which are not
    pub included_in_store: Option<bool>,
    /// If the product is included in the online store
    pub available_in_store: Option<bool>,
    /// The order of sort which should be applied for the date
    /// Allowed values: `asc`, `desc`.
    pub sort_order: Option<String>,
}

impl ListProductsParams {
    /// Start from the parameters the API requires.
    pub fn new(location_id: impl Into<String>) -> Self {
        Self {
            location_id: location_id.into(),
            ..Default::default()
        }
    }

    /// The maximum number of items to be included in a single page of results
    pub fn limit(mut self, v: f64) -> Self {
        self.limit = Some(v);
        self
    }

    /// The starting index of the page, indicating the position from which the results
    /// should be retrieved.
    pub fn offset(mut self, v: f64) -> Self {
        self.offset = Some(v);
        self
    }

    /// The name of the product for searching.
    pub fn search(mut self, v: impl Into<String>) -> Self {
        self.search = Some(v.into());
        self
    }

    /// Filter by product category Ids. Supports comma separated values
    pub fn collection_ids(mut self, v: impl Into<String>) -> Self {
        self.collection_ids = Some(v.into());
        self
    }

    /// The slug value of the collection by which the collection would be searched
    pub fn collection_slug(mut self, v: impl Into<String>) -> Self {
        self.collection_slug = Some(v.into());
        self
    }

    /// Name of an entity whose data has to be fetched along with product. Possible entities
    /// are tax, stripe and paypal. If not mentioned, only ID will be returned in case of
    /// taxes
    pub fn expand(mut self, v: impl Into<String>) -> Self {
        self.expand = Some(v.into());
        self
    }

    /// List of product ids to be fetched.
    pub fn product_ids(mut self, v: impl Into<String>) -> Self {
        self.product_ids = Some(v.into());
        self
    }

    /// fetch and project products based on the storeId
    pub fn store_id(mut self, v: impl Into<String>) -> Self {
        self.store_id = Some(v.into());
        self
    }

    /// Separate products by which are included in the store and which are not
    pub fn included_in_store(mut self, v: bool) -> Self {
        self.included_in_store = Some(v);
        self
    }

    /// If the product is included in the online store
    pub fn available_in_store(mut self, v: bool) -> Self {
        self.available_in_store = Some(v);
        self
    }

    /// The order of sort which should be applied for the date
    pub fn sort_order(mut self, v: impl Into<String>) -> Self {
        self.sort_order = Some(v.into());
        self
    }

    fn to_query(&self) -> Vec<(String, String)> {
        let mut q: Vec<(String, String)> = vec![("locationId".into(), self.location_id.clone())];
        if let Some(v) = &self.limit {
            q.push(("limit".into(), v.to_string()));
        }
        if let Some(v) = &self.offset {
            q.push(("offset".into(), v.to_string()));
        }
        if let Some(v) = &self.search {
            q.push(("search".into(), v.to_string()));
        }
        if let Some(v) = &self.collection_ids {
            q.push(("collectionIds".into(), v.to_string()));
        }
        if let Some(v) = &self.collection_slug {
            q.push(("collectionSlug".into(), v.to_string()));
        }
        if let Some(v) = &self.expand {
            q.push(("expand".into(), v.to_string()));
        }
        if let Some(v) = &self.product_ids {
            q.push(("productIds".into(), v.to_string()));
        }
        if let Some(v) = &self.store_id {
            q.push(("storeId".into(), v.to_string()));
        }
        if let Some(v) = &self.included_in_store {
            q.push(("includedInStore".into(), v.to_string()));
        }
        if let Some(v) = &self.available_in_store {
            q.push(("availableInStore".into(), v.to_string()));
        }
        if let Some(v) = &self.sort_order {
            q.push(("sortOrder".into(), v.to_string()));
        }
        q
    }
}

/// Query parameters for [`ProductsService::fetch_product_collections`].
#[derive(Debug, Clone, Default)]
pub struct FetchProductCollectionsParams {
    /// The maximum number of items to be included in a single page of results
    pub limit: Option<f64>,
    /// The starting index of the page, indicating the position from which the results
    /// should be retrieved.
    pub offset: Option<f64>,
    /// Location Id
    /// Required by the API.
    pub alt_id: String,
    /// The type of alt. For now it is only LOCATION
    /// Allowed values: `location`.
    /// Required by the API.
    pub alt_type: String,
    /// Ids of the collections separated by comma(,) for search purposes
    pub collection_ids: Option<String>,
    /// Query to search collection based on names
    pub name: Option<String>,
}

impl FetchProductCollectionsParams {
    /// Start from the parameters the API requires.
    pub fn new(alt_id: impl Into<String>, alt_type: impl Into<String>) -> Self {
        Self {
            alt_id: alt_id.into(),
            alt_type: alt_type.into(),
            ..Default::default()
        }
    }

    /// The maximum number of items to be included in a single page of results
    pub fn limit(mut self, v: f64) -> Self {
        self.limit = Some(v);
        self
    }

    /// The starting index of the page, indicating the position from which the results
    /// should be retrieved.
    pub fn offset(mut self, v: f64) -> Self {
        self.offset = Some(v);
        self
    }

    /// Ids of the collections separated by comma(,) for search purposes
    pub fn collection_ids(mut self, v: impl Into<String>) -> Self {
        self.collection_ids = Some(v.into());
        self
    }

    /// Query to search collection based on names
    pub fn name(mut self, v: impl Into<String>) -> Self {
        self.name = Some(v.into());
        self
    }

    fn to_query(&self) -> Vec<(String, String)> {
        let mut q: Vec<(String, String)> = vec![
            ("altId".into(), self.alt_id.clone()),
            ("altType".into(), self.alt_type.clone()),
        ];
        if let Some(v) = &self.limit {
            q.push(("limit".into(), v.to_string()));
        }
        if let Some(v) = &self.offset {
            q.push(("offset".into(), v.to_string()));
        }
        if let Some(v) = &self.collection_ids {
            q.push(("collectionIds".into(), v.to_string()));
        }
        if let Some(v) = &self.name {
            q.push(("name".into(), v.to_string()));
        }
        q
    }
}

/// Query parameters for [`ProductsService::delete_product_collection`].
#[derive(Debug, Clone, Default)]
pub struct DeleteProductCollectionParams {
    /// Location Id
    /// Required by the API.
    pub alt_id: String,
    /// The type of alt. For now it is only LOCATION
    /// Allowed values: `location`.
    /// Required by the API.
    pub alt_type: String,
}

impl DeleteProductCollectionParams {
    /// Start from the parameters the API requires.
    pub fn new(alt_id: impl Into<String>, alt_type: impl Into<String>) -> Self {
        Self {
            alt_id: alt_id.into(),
            alt_type: alt_type.into(),
        }
    }

    fn to_query(&self) -> Vec<(String, String)> {
        let q: Vec<(String, String)> = vec![
            ("altId".into(), self.alt_id.clone()),
            ("altType".into(), self.alt_type.clone()),
        ];
        q
    }
}

/// Query parameters for
/// [`ProductsService::get_details_about_individual_product_collection`].
#[derive(Debug, Clone, Default)]
pub struct GetDetailsAboutIndividualProductCollectionParams {
    /// Location Id
    /// Required by the API.
    pub alt_id: String,
}

impl GetDetailsAboutIndividualProductCollectionParams {
    /// Start from the parameters the API requires.
    pub fn new(alt_id: impl Into<String>) -> Self {
        Self {
            alt_id: alt_id.into(),
        }
    }

    fn to_query(&self) -> Vec<(String, String)> {
        let q: Vec<(String, String)> = vec![("altId".into(), self.alt_id.clone())];
        q
    }
}

/// Query parameters for [`ProductsService::list_inventory`].
#[derive(Debug, Clone, Default)]
pub struct ListInventoryParams {
    /// The maximum number of items to be included in a single page of results
    pub limit: Option<f64>,
    /// The starting index of the page, indicating the position from which the results
    /// should be retrieved.
    pub offset: Option<f64>,
    /// Location Id or Agency Id
    /// Required by the API.
    pub alt_id: String,
    /// `altType` query parameter.
    /// Allowed values: `location`.
    /// Required by the API.
    pub alt_type: String,
    /// Search string for Variant Search
    pub search: Option<String>,
}

impl ListInventoryParams {
    /// Start from the parameters the API requires.
    pub fn new(alt_id: impl Into<String>, alt_type: impl Into<String>) -> Self {
        Self {
            alt_id: alt_id.into(),
            alt_type: alt_type.into(),
            ..Default::default()
        }
    }

    /// The maximum number of items to be included in a single page of results
    pub fn limit(mut self, v: f64) -> Self {
        self.limit = Some(v);
        self
    }

    /// The starting index of the page, indicating the position from which the results
    /// should be retrieved.
    pub fn offset(mut self, v: f64) -> Self {
        self.offset = Some(v);
        self
    }

    /// Search string for Variant Search
    pub fn search(mut self, v: impl Into<String>) -> Self {
        self.search = Some(v.into());
        self
    }

    fn to_query(&self) -> Vec<(String, String)> {
        let mut q: Vec<(String, String)> = vec![
            ("altId".into(), self.alt_id.clone()),
            ("altType".into(), self.alt_type.clone()),
        ];
        if let Some(v) = &self.limit {
            q.push(("limit".into(), v.to_string()));
        }
        if let Some(v) = &self.offset {
            q.push(("offset".into(), v.to_string()));
        }
        if let Some(v) = &self.search {
            q.push(("search".into(), v.to_string()));
        }
        q
    }
}

/// Query parameters for [`ProductsService::fetch_product_reviews`].
#[derive(Debug, Clone, Default)]
pub struct FetchProductReviewsParams {
    /// Location Id or Agency Id
    /// Required by the API.
    pub alt_id: String,
    /// `altType` query parameter.
    /// Allowed values: `location`.
    /// Required by the API.
    pub alt_type: String,
    /// The maximum number of items to be included in a single page of results
    pub limit: Option<f64>,
    /// The starting index of the page, indicating the position from which the results
    /// should be retrieved.
    pub offset: Option<f64>,
    /// The field upon which the sort should be applied
    /// Allowed values: `createdAt`, `rating`.
    pub sort_field: Option<String>,
    /// The order of sort which should be applied for the sortField
    /// Allowed values: `asc`, `desc`.
    pub sort_order: Option<String>,
    /// Key to filter the ratings
    pub rating: Option<f64>,
    /// The start date for filtering reviews
    pub start_date: Option<String>,
    /// The end date for filtering reviews
    pub end_date: Option<String>,
    /// Comma-separated list of product IDs
    pub product_id: Option<String>,
    /// Comma-separated list of store IDs
    pub store_id: Option<String>,
}

impl FetchProductReviewsParams {
    /// Start from the parameters the API requires.
    pub fn new(alt_id: impl Into<String>, alt_type: impl Into<String>) -> Self {
        Self {
            alt_id: alt_id.into(),
            alt_type: alt_type.into(),
            ..Default::default()
        }
    }

    /// The maximum number of items to be included in a single page of results
    pub fn limit(mut self, v: f64) -> Self {
        self.limit = Some(v);
        self
    }

    /// The starting index of the page, indicating the position from which the results
    /// should be retrieved.
    pub fn offset(mut self, v: f64) -> Self {
        self.offset = Some(v);
        self
    }

    /// The field upon which the sort should be applied
    pub fn sort_field(mut self, v: impl Into<String>) -> Self {
        self.sort_field = Some(v.into());
        self
    }

    /// The order of sort which should be applied for the sortField
    pub fn sort_order(mut self, v: impl Into<String>) -> Self {
        self.sort_order = Some(v.into());
        self
    }

    /// Key to filter the ratings
    pub fn rating(mut self, v: f64) -> Self {
        self.rating = Some(v);
        self
    }

    /// The start date for filtering reviews
    pub fn start_date(mut self, v: impl Into<String>) -> Self {
        self.start_date = Some(v.into());
        self
    }

    /// The end date for filtering reviews
    pub fn end_date(mut self, v: impl Into<String>) -> Self {
        self.end_date = Some(v.into());
        self
    }

    /// Comma-separated list of product IDs
    pub fn product_id(mut self, v: impl Into<String>) -> Self {
        self.product_id = Some(v.into());
        self
    }

    /// Comma-separated list of store IDs
    pub fn store_id(mut self, v: impl Into<String>) -> Self {
        self.store_id = Some(v.into());
        self
    }

    fn to_query(&self) -> Vec<(String, String)> {
        let mut q: Vec<(String, String)> = vec![
            ("altId".into(), self.alt_id.clone()),
            ("altType".into(), self.alt_type.clone()),
        ];
        if let Some(v) = &self.limit {
            q.push(("limit".into(), v.to_string()));
        }
        if let Some(v) = &self.offset {
            q.push(("offset".into(), v.to_string()));
        }
        if let Some(v) = &self.sort_field {
            q.push(("sortField".into(), v.to_string()));
        }
        if let Some(v) = &self.sort_order {
            q.push(("sortOrder".into(), v.to_string()));
        }
        if let Some(v) = &self.rating {
            q.push(("rating".into(), v.to_string()));
        }
        if let Some(v) = &self.start_date {
            q.push(("startDate".into(), v.to_string()));
        }
        if let Some(v) = &self.end_date {
            q.push(("endDate".into(), v.to_string()));
        }
        if let Some(v) = &self.product_id {
            q.push(("productId".into(), v.to_string()));
        }
        if let Some(v) = &self.store_id {
            q.push(("storeId".into(), v.to_string()));
        }
        q
    }
}

/// Query parameters for [`ProductsService::fetch_review_count_as_per_status`].
#[derive(Debug, Clone, Default)]
pub struct FetchReviewCountAsPerStatusParams {
    /// Location Id or Agency Id
    /// Required by the API.
    pub alt_id: String,
    /// `altType` query parameter.
    /// Allowed values: `location`.
    /// Required by the API.
    pub alt_type: String,
    /// Key to filter the ratings
    pub rating: Option<f64>,
    /// The start date for filtering reviews
    pub start_date: Option<String>,
    /// The end date for filtering reviews
    pub end_date: Option<String>,
    /// Comma-separated list of product IDs
    pub product_id: Option<String>,
    /// Comma-separated list of store IDs
    pub store_id: Option<String>,
}

impl FetchReviewCountAsPerStatusParams {
    /// Start from the parameters the API requires.
    pub fn new(alt_id: impl Into<String>, alt_type: impl Into<String>) -> Self {
        Self {
            alt_id: alt_id.into(),
            alt_type: alt_type.into(),
            ..Default::default()
        }
    }

    /// Key to filter the ratings
    pub fn rating(mut self, v: f64) -> Self {
        self.rating = Some(v);
        self
    }

    /// The start date for filtering reviews
    pub fn start_date(mut self, v: impl Into<String>) -> Self {
        self.start_date = Some(v.into());
        self
    }

    /// The end date for filtering reviews
    pub fn end_date(mut self, v: impl Into<String>) -> Self {
        self.end_date = Some(v.into());
        self
    }

    /// Comma-separated list of product IDs
    pub fn product_id(mut self, v: impl Into<String>) -> Self {
        self.product_id = Some(v.into());
        self
    }

    /// Comma-separated list of store IDs
    pub fn store_id(mut self, v: impl Into<String>) -> Self {
        self.store_id = Some(v.into());
        self
    }

    fn to_query(&self) -> Vec<(String, String)> {
        let mut q: Vec<(String, String)> = vec![
            ("altId".into(), self.alt_id.clone()),
            ("altType".into(), self.alt_type.clone()),
        ];
        if let Some(v) = &self.rating {
            q.push(("rating".into(), v.to_string()));
        }
        if let Some(v) = &self.start_date {
            q.push(("startDate".into(), v.to_string()));
        }
        if let Some(v) = &self.end_date {
            q.push(("endDate".into(), v.to_string()));
        }
        if let Some(v) = &self.product_id {
            q.push(("productId".into(), v.to_string()));
        }
        if let Some(v) = &self.store_id {
            q.push(("storeId".into(), v.to_string()));
        }
        q
    }
}

/// Query parameters for [`ProductsService::delete_product_review`].
#[derive(Debug, Clone, Default)]
pub struct DeleteProductReviewParams {
    /// Location Id or Agency Id
    /// Required by the API.
    pub alt_id: String,
    /// `altType` query parameter.
    /// Allowed values: `location`.
    /// Required by the API.
    pub alt_type: String,
    /// Product Id of the product
    /// Required by the API.
    pub product_id: String,
}

impl DeleteProductReviewParams {
    /// Start from the parameters the API requires.
    pub fn new(
        alt_id: impl Into<String>,
        alt_type: impl Into<String>,
        product_id: impl Into<String>,
    ) -> Self {
        Self {
            alt_id: alt_id.into(),
            alt_type: alt_type.into(),
            product_id: product_id.into(),
        }
    }

    fn to_query(&self) -> Vec<(String, String)> {
        let q: Vec<(String, String)> = vec![
            ("altId".into(), self.alt_id.clone()),
            ("altType".into(), self.alt_type.clone()),
            ("productId".into(), self.product_id.clone()),
        ];
        q
    }
}

/// Query parameters for [`ProductsService::fetch_product_store_stats`].
#[derive(Debug, Clone, Default)]
pub struct FetchProductStoreStatsParams {
    /// Location Id or Agency Id
    /// Required by the API.
    pub alt_id: String,
    /// `altType` query parameter.
    /// Allowed values: `location`.
    /// Required by the API.
    pub alt_type: String,
    /// The name of the product for searching.
    pub search: Option<String>,
    /// Filter by product collection Ids. Supports comma separated values
    pub collection_ids: Option<String>,
}

impl FetchProductStoreStatsParams {
    /// Start from the parameters the API requires.
    pub fn new(alt_id: impl Into<String>, alt_type: impl Into<String>) -> Self {
        Self {
            alt_id: alt_id.into(),
            alt_type: alt_type.into(),
            ..Default::default()
        }
    }

    /// The name of the product for searching.
    pub fn search(mut self, v: impl Into<String>) -> Self {
        self.search = Some(v.into());
        self
    }

    /// Filter by product collection Ids. Supports comma separated values
    pub fn collection_ids(mut self, v: impl Into<String>) -> Self {
        self.collection_ids = Some(v.into());
        self
    }

    fn to_query(&self) -> Vec<(String, String)> {
        let mut q: Vec<(String, String)> = vec![
            ("altId".into(), self.alt_id.clone()),
            ("altType".into(), self.alt_type.clone()),
        ];
        if let Some(v) = &self.search {
            q.push(("search".into(), v.to_string()));
        }
        if let Some(v) = &self.collection_ids {
            q.push(("collectionIds".into(), v.to_string()));
        }
        q
    }
}

/// Query parameters for [`ProductsService::delete_product_by_id`].
#[derive(Debug, Clone, Default)]
pub struct DeleteProductByIdParams {
    /// location Id
    /// Required by the API.
    pub location_id: String,
    /// Parameter which will decide whether to show the wishlisting status of products
    pub send_wishlist_status: Option<bool>,
}

impl DeleteProductByIdParams {
    /// Start from the parameters the API requires.
    pub fn new(location_id: impl Into<String>) -> Self {
        Self {
            location_id: location_id.into(),
            ..Default::default()
        }
    }

    /// Parameter which will decide whether to show the wishlisting status of products
    pub fn send_wishlist_status(mut self, v: bool) -> Self {
        self.send_wishlist_status = Some(v);
        self
    }

    fn to_query(&self) -> Vec<(String, String)> {
        let mut q: Vec<(String, String)> = vec![("locationId".into(), self.location_id.clone())];
        if let Some(v) = &self.send_wishlist_status {
            q.push(("sendWishlistStatus".into(), v.to_string()));
        }
        q
    }
}

/// Query parameters for [`ProductsService::get_product_by_id`].
#[derive(Debug, Clone, Default)]
pub struct GetProductByIdParams {
    /// location Id
    /// Required by the API.
    pub location_id: String,
    /// Parameter which will decide whether to show the wishlisting status of products
    pub send_wishlist_status: Option<bool>,
}

impl GetProductByIdParams {
    /// Start from the parameters the API requires.
    pub fn new(location_id: impl Into<String>) -> Self {
        Self {
            location_id: location_id.into(),
            ..Default::default()
        }
    }

    /// Parameter which will decide whether to show the wishlisting status of products
    pub fn send_wishlist_status(mut self, v: bool) -> Self {
        self.send_wishlist_status = Some(v);
        self
    }

    fn to_query(&self) -> Vec<(String, String)> {
        let mut q: Vec<(String, String)> = vec![("locationId".into(), self.location_id.clone())];
        if let Some(v) = &self.send_wishlist_status {
            q.push(("sendWishlistStatus".into(), v.to_string()));
        }
        q
    }
}

/// Query parameters for [`ProductsService::list_prices_for_a_product`].
#[derive(Debug, Clone, Default)]
pub struct ListPricesForAProductParams {
    /// The maximum number of items to be included in a single page of results
    pub limit: Option<f64>,
    /// The starting index of the page, indicating the position from which the results
    /// should be retrieved.
    pub offset: Option<f64>,
    /// The unique identifier for the location.
    /// Required by the API.
    pub location_id: String,
    /// To filter the response only with the given price ids, Please provide with comma
    /// separated
    pub ids: Option<String>,
}

impl ListPricesForAProductParams {
    /// Start from the parameters the API requires.
    pub fn new(location_id: impl Into<String>) -> Self {
        Self {
            location_id: location_id.into(),
            ..Default::default()
        }
    }

    /// The maximum number of items to be included in a single page of results
    pub fn limit(mut self, v: f64) -> Self {
        self.limit = Some(v);
        self
    }

    /// The starting index of the page, indicating the position from which the results
    /// should be retrieved.
    pub fn offset(mut self, v: f64) -> Self {
        self.offset = Some(v);
        self
    }

    /// To filter the response only with the given price ids, Please provide with comma
    /// separated
    pub fn ids(mut self, v: impl Into<String>) -> Self {
        self.ids = Some(v.into());
        self
    }

    fn to_query(&self) -> Vec<(String, String)> {
        let mut q: Vec<(String, String)> = vec![("locationId".into(), self.location_id.clone())];
        if let Some(v) = &self.limit {
            q.push(("limit".into(), v.to_string()));
        }
        if let Some(v) = &self.offset {
            q.push(("offset".into(), v.to_string()));
        }
        if let Some(v) = &self.ids {
            q.push(("ids".into(), v.to_string()));
        }
        q
    }
}

/// Query parameters for [`ProductsService::delete_price_by_id_for_a_product`].
#[derive(Debug, Clone, Default)]
pub struct DeletePriceByIdForAProductParams {
    /// location Id
    /// Required by the API.
    pub location_id: String,
}

impl DeletePriceByIdForAProductParams {
    /// Start from the parameters the API requires.
    pub fn new(location_id: impl Into<String>) -> Self {
        Self {
            location_id: location_id.into(),
        }
    }

    fn to_query(&self) -> Vec<(String, String)> {
        let q: Vec<(String, String)> = vec![("locationId".into(), self.location_id.clone())];
        q
    }
}

/// Query parameters for [`ProductsService::get_price_by_id_for_a_product`].
#[derive(Debug, Clone, Default)]
pub struct GetPriceByIdForAProductParams {
    /// location Id
    /// Required by the API.
    pub location_id: String,
}

impl GetPriceByIdForAProductParams {
    /// Start from the parameters the API requires.
    pub fn new(location_id: impl Into<String>) -> Self {
        Self {
            location_id: location_id.into(),
        }
    }

    fn to_query(&self) -> Vec<(String, String)> {
        let q: Vec<(String, String)> = vec![("locationId".into(), self.location_id.clone())];
        q
    }
}

impl ProductsService {
    /// List Products
    ///
    /// The "List Products" API allows to retrieve a paginated list of products. Customize
    /// your results by filtering products based on name or paginate through the list using
    /// the provided query parameters. This endpoint provides a straightforward way to
    /// explore and retrieve product information.
    ///
    /// `GET /products/`
    ///
    /// Requires scope: `products.readonly`.
    pub async fn list_products(
        &self,
        params: &ListProductsParams,
    ) -> Result<models::ListProductsResponseDto> {
        let query = params.to_query();
        self.client
            .send_versioned(
                reqwest::Method::GET,
                "/products/",
                &query,
                None::<&()>,
                Some("2021-07-28"),
            )
            .await
    }

    /// Create Product
    ///
    /// The "Create Product" API allows adding a new product to the system. Use this
    /// endpoint to create a product with the specified details. Ensure that the required
    /// information is provided in the request payload.
    ///
    /// `POST /products/`
    ///
    /// Requires scope: `products.write`.
    pub async fn create_product(
        &self,
        body: &models::CreateProductDto,
    ) -> Result<models::CreateProductResponseDto> {
        let query = Vec::new();
        self.client
            .send_versioned(
                reqwest::Method::POST,
                "/products/",
                &query,
                Some(body),
                Some("2021-07-28"),
            )
            .await
    }

    /// Bulk Update Products
    ///
    /// API to bulk update products (price, availability, collections, delete)
    ///
    /// `POST /products/bulk-update`
    ///
    /// Requires scope: `products.write`.
    pub async fn bulk_update_products(
        &self,
        body: &models::BulkUpdateDto,
    ) -> Result<models::BulkUpdateResponseDto> {
        let query = Vec::new();
        self.client
            .send_versioned(
                reqwest::Method::POST,
                "/products/bulk-update",
                &query,
                Some(body),
                Some("2021-07-28"),
            )
            .await
    }

    /// Bulk Edit Products and Prices
    ///
    /// API to bulk edit products and their associated prices (max 30 entities)
    ///
    /// `POST /products/bulk-update/edit`
    pub async fn bulk_edit_products_and_prices(
        &self,
        body: &models::BulkEditRequestDto,
    ) -> Result<models::BulkEditResponseDto> {
        let query = Vec::new();
        self.client
            .send_versioned(
                reqwest::Method::POST,
                "/products/bulk-update/edit",
                &query,
                Some(body),
                Some("2021-07-28"),
            )
            .await
    }

    /// Fetch Product Collections
    ///
    /// Internal API to fetch the Product Collections
    ///
    /// `GET /products/collections`
    ///
    /// Requires scope: `products/collection.readonly`.
    pub async fn fetch_product_collections(
        &self,
        params: &FetchProductCollectionsParams,
    ) -> Result<models::ListCollectionResponseDto> {
        let query = params.to_query();
        self.client
            .send_versioned(
                reqwest::Method::GET,
                "/products/collections",
                &query,
                None::<&()>,
                Some("2021-07-28"),
            )
            .await
    }

    /// Create Product Collection
    ///
    /// Create a new Product Collection for a specific location
    ///
    /// `POST /products/collections`
    ///
    /// Requires scope: `products/collection.write`.
    pub async fn create_product_collection(
        &self,
        body: &models::CreateProductCollectionsDto,
    ) -> Result<models::CreateCollectionResponseDto> {
        let query = Vec::new();
        self.client
            .send_versioned(
                reqwest::Method::POST,
                "/products/collections",
                &query,
                Some(body),
                Some("2021-07-28"),
            )
            .await
    }

    /// Delete Product Collection
    ///
    /// Delete specific product collection with Id :collectionId
    ///
    /// `DELETE /products/collections/{collectionId}`
    ///
    /// Requires scope: `products/collection.write`.
    pub async fn delete_product_collection(
        &self,
        collection_id: &str,
        params: &DeleteProductCollectionParams,
    ) -> Result<models::DeleteProductCollectionResponseDto> {
        let path = format!(
            "/products/collections/{}",
            crate::services::encode(collection_id)
        );
        let query = params.to_query();
        self.client
            .send_versioned(
                reqwest::Method::DELETE,
                &path,
                &query,
                None::<&()>,
                Some("2021-07-28"),
            )
            .await
    }

    /// Get Details about individual product collection
    ///
    /// `GET /products/collections/{collectionId}`
    ///
    /// Requires scope: `products/collection.readonly`.
    pub async fn get_details_about_individual_product_collection(
        &self,
        collection_id: &str,
        params: &GetDetailsAboutIndividualProductCollectionParams,
    ) -> Result<models::DefaultCollectionResponseDto> {
        let path = format!(
            "/products/collections/{}",
            crate::services::encode(collection_id)
        );
        let query = params.to_query();
        self.client
            .send_versioned(
                reqwest::Method::GET,
                &path,
                &query,
                None::<&()>,
                Some("2021-07-28"),
            )
            .await
    }

    /// Update Product Collection
    ///
    /// Update a specific product collection with Id :collectionId
    ///
    /// `PUT /products/collections/{collectionId}`
    ///
    /// Requires scope: `products/collection.write`.
    pub async fn update_product_collection(
        &self,
        collection_id: &str,
        body: &models::UpdateProductCollectionsDto,
    ) -> Result<models::UpdateProductCollectionResponseDto> {
        let path = format!(
            "/products/collections/{}",
            crate::services::encode(collection_id)
        );
        let query = Vec::new();
        self.client
            .send_versioned(
                reqwest::Method::PUT,
                &path,
                &query,
                Some(body),
                Some("2021-07-28"),
            )
            .await
    }

    /// List Inventory
    ///
    /// The "List Inventory API allows the user to retrieve a paginated list of inventory
    /// items. Use this endpoint to fetch details for multiple items in the inventory based
    /// on the provided query parameters.
    ///
    /// `GET /products/inventory`
    ///
    /// Requires scope: `products/prices.readonly`.
    pub async fn list_inventory(
        &self,
        params: &ListInventoryParams,
    ) -> Result<models::GetInventoryResponseDto> {
        let query = params.to_query();
        self.client
            .send_versioned(
                reqwest::Method::GET,
                "/products/inventory",
                &query,
                None::<&()>,
                Some("2021-07-28"),
            )
            .await
    }

    /// Update Inventory
    ///
    /// The Update Inventory API allows the user to bulk update the inventory for multiple
    /// items. Use this endpoint to update the available quantity and out-of-stock purchase
    /// settings for multiple items in the inventory.
    ///
    /// `POST /products/inventory`
    ///
    /// Requires scope: `products/prices.write`.
    pub async fn update_inventory(
        &self,
        body: &models::UpdateInventoryDto,
    ) -> Result<models::UpdateInventoryResponseDto> {
        let query = Vec::new();
        self.client
            .send_versioned(
                reqwest::Method::POST,
                "/products/inventory",
                &query,
                Some(body),
                Some("2021-07-28"),
            )
            .await
    }

    /// Fetch Product Reviews
    ///
    /// API to fetch the Product Reviews
    ///
    /// `GET /products/reviews`
    ///
    /// Requires scope: `products.readonly`.
    pub async fn fetch_product_reviews(
        &self,
        params: &FetchProductReviewsParams,
    ) -> Result<models::ListProductReviewsResponseDto> {
        let query = params.to_query();
        self.client
            .send_versioned(
                reqwest::Method::GET,
                "/products/reviews",
                &query,
                None::<&()>,
                Some("2021-07-28"),
            )
            .await
    }

    /// Update Product Reviews
    ///
    /// Update one or multiple product reviews: status, reply, etc.
    ///
    /// `POST /products/reviews/bulk-update`
    ///
    /// Requires scope: `products.write`.
    pub async fn update_product_reviews(
        &self,
        body: &models::UpdateProductReviewsDto,
    ) -> Result<models::UpdateProductReviewsResponseDto> {
        let query = Vec::new();
        self.client
            .send_versioned(
                reqwest::Method::POST,
                "/products/reviews/bulk-update",
                &query,
                Some(body),
                Some("2021-07-28"),
            )
            .await
    }

    /// Fetch Review Count as per status
    ///
    /// API to fetch the Review Count as per status
    ///
    /// `GET /products/reviews/count`
    ///
    /// Requires scope: `products.readonly`.
    pub async fn fetch_review_count_as_per_status(
        &self,
        params: &FetchReviewCountAsPerStatusParams,
    ) -> Result<models::CountReviewsByStatusResponseDto> {
        let query = params.to_query();
        self.client
            .send_versioned(
                reqwest::Method::GET,
                "/products/reviews/count",
                &query,
                None::<&()>,
                Some("2021-07-28"),
            )
            .await
    }

    /// Delete Product Review
    ///
    /// Delete specific product review
    ///
    /// `DELETE /products/reviews/{reviewId}`
    ///
    /// Requires scope: `products.write`.
    pub async fn delete_product_review(
        &self,
        review_id: &str,
        params: &DeleteProductReviewParams,
    ) -> Result<models::DeleteProductReviewResponseDto> {
        let path = format!("/products/reviews/{}", crate::services::encode(review_id));
        let query = params.to_query();
        self.client
            .send_versioned(
                reqwest::Method::DELETE,
                &path,
                &query,
                None::<&()>,
                Some("2021-07-28"),
            )
            .await
    }

    /// Update Product Reviews
    ///
    /// Update status, reply, etc of a particular review
    ///
    /// `PUT /products/reviews/{reviewId}`
    ///
    /// Requires scope: `products.write`.
    pub async fn update_product_reviews_op(
        &self,
        review_id: &str,
        body: &models::UpdateProductReviewDto,
    ) -> Result<models::UpdateProductReviewsResponseDto> {
        let path = format!("/products/reviews/{}", crate::services::encode(review_id));
        let query = Vec::new();
        self.client
            .send_versioned(
                reqwest::Method::PUT,
                &path,
                &query,
                Some(body),
                Some("2021-07-28"),
            )
            .await
    }

    /// Action to include/exclude the product in store
    ///
    /// API to update the status of products in a particular store
    ///
    /// `POST /products/store/{storeId}`
    ///
    /// Requires scope: `products.write`.
    pub async fn action_to_include_exclude_the_product_in_store(
        &self,
        store_id: &str,
        body: &models::UpdateProductStoreDto,
    ) -> Result<models::UpdateProductStoreResponseDto> {
        let path = format!("/products/store/{}", crate::services::encode(store_id));
        let query = Vec::new();
        self.client
            .send_versioned(
                reqwest::Method::POST,
                &path,
                &query,
                Some(body),
                Some("2021-07-28"),
            )
            .await
    }

    /// Update product display priorities in store
    ///
    /// API to set the display priority of products in a store
    ///
    /// `POST /products/store/{storeId}/priority`
    pub async fn update_product_display_priorities_in_store(
        &self,
        store_id: &str,
        body: &models::UpdateDisplayPriorityBodyDto,
    ) -> Result<serde_json::Value> {
        let path = format!(
            "/products/store/{}/priority",
            crate::services::encode(store_id)
        );
        let query = Vec::new();
        self.client
            .send_versioned(
                reqwest::Method::POST,
                &path,
                &query,
                Some(body),
                Some("2021-07-28"),
            )
            .await
    }

    /// Fetch Product Store Stats
    ///
    /// API to fetch the total number of products, included in the store, and excluded from
    /// the store and other stats
    ///
    /// `GET /products/store/{storeId}/stats`
    ///
    /// Requires scope: `products.readonly`.
    pub async fn fetch_product_store_stats(
        &self,
        store_id: &str,
        params: &FetchProductStoreStatsParams,
    ) -> Result<models::GetProductStatsResponseDto> {
        let path = format!(
            "/products/store/{}/stats",
            crate::services::encode(store_id)
        );
        let query = params.to_query();
        self.client
            .send_versioned(
                reqwest::Method::GET,
                &path,
                &query,
                None::<&()>,
                Some("2021-07-28"),
            )
            .await
    }

    /// Delete Product by ID
    ///
    /// The "Delete Product by ID" API allows deleting a specific product using its unique
    /// identifier. Use this endpoint to remove a product from the system.
    ///
    /// `DELETE /products/{productId}`
    ///
    /// Requires scope: `products.write`.
    pub async fn delete_product_by_id(
        &self,
        product_id: &str,
        params: &DeleteProductByIdParams,
    ) -> Result<models::DeleteProductResponseDto> {
        let path = format!("/products/{}", crate::services::encode(product_id));
        let query = params.to_query();
        self.client
            .send_versioned(
                reqwest::Method::DELETE,
                &path,
                &query,
                None::<&()>,
                Some("2021-07-28"),
            )
            .await
    }

    /// Get Product by ID
    ///
    /// The "Get Product by ID" API allows to retrieve information for a specific product
    /// using its unique identifier. Use this endpoint to fetch details for a single product
    /// based on the provided product ID.
    ///
    /// `GET /products/{productId}`
    ///
    /// Requires scope: `products.readonly`.
    pub async fn get_product_by_id(
        &self,
        product_id: &str,
        params: &GetProductByIdParams,
    ) -> Result<models::GetProductResponseDto> {
        let path = format!("/products/{}", crate::services::encode(product_id));
        let query = params.to_query();
        self.client
            .send_versioned(
                reqwest::Method::GET,
                &path,
                &query,
                None::<&()>,
                Some("2021-07-28"),
            )
            .await
    }

    /// Update Product by ID
    ///
    /// The "Update Product by ID" API allows modifying information for a specific product
    /// using its unique identifier. Use this endpoint to update details for a single
    /// product based on the provided product ID.
    ///
    /// `PUT /products/{productId}`
    ///
    /// Requires scope: `products.write`.
    pub async fn update_product_by_id(
        &self,
        product_id: &str,
        body: &models::UpdateProductDto,
    ) -> Result<models::UpdateProductResponseDto> {
        let path = format!("/products/{}", crate::services::encode(product_id));
        let query = Vec::new();
        self.client
            .send_versioned(
                reqwest::Method::PUT,
                &path,
                &query,
                Some(body),
                Some("2021-07-28"),
            )
            .await
    }

    /// List Prices for a Product
    ///
    /// The "List Prices for a Product" API allows retrieving a paginated list of prices
    /// associated with a specific product. Customize your results by filtering prices or
    /// paginate through the list using the provided query parameters.
    ///
    /// `GET /products/{productId}/price`
    ///
    /// Requires scope: `products/prices.readonly`.
    pub async fn list_prices_for_a_product(
        &self,
        product_id: &str,
        params: &ListPricesForAProductParams,
    ) -> Result<models::ListPricesResponseDto> {
        let path = format!("/products/{}/price", crate::services::encode(product_id));
        let query = params.to_query();
        self.client
            .send_versioned(
                reqwest::Method::GET,
                &path,
                &query,
                None::<&()>,
                Some("2021-07-28"),
            )
            .await
    }

    /// Create Price for a Product
    ///
    /// The "Create Price for a Product" API allows adding a new price associated with a
    /// specific product to the system. Use this endpoint to create a price with the
    /// specified details for a particular product. Ensure that the required information is
    /// provided in the request payload.
    ///
    /// `POST /products/{productId}/price`
    ///
    /// Requires scope: `products/prices.write`.
    pub async fn create_price_for_a_product(
        &self,
        product_id: &str,
        body: &models::CreatePriceDto,
    ) -> Result<models::CreatePriceResponseDto> {
        let path = format!("/products/{}/price", crate::services::encode(product_id));
        let query = Vec::new();
        self.client
            .send_versioned(
                reqwest::Method::POST,
                &path,
                &query,
                Some(body),
                Some("2021-07-28"),
            )
            .await
    }

    /// Delete Price by ID for a Product
    ///
    /// The "Delete Price by ID for a Product" API allows deleting a specific price
    /// associated with a particular product using its unique identifier. Use this endpoint
    /// to remove a price from the system.
    ///
    /// `DELETE /products/{productId}/price/{priceId}`
    ///
    /// Requires scope: `products/prices.write`.
    pub async fn delete_price_by_id_for_a_product(
        &self,
        product_id: &str,
        price_id: &str,
        params: &DeletePriceByIdForAProductParams,
    ) -> Result<models::DeletePriceResponseDto> {
        let path = format!(
            "/products/{}/price/{}",
            crate::services::encode(product_id),
            crate::services::encode(price_id)
        );
        let query = params.to_query();
        self.client
            .send_versioned(
                reqwest::Method::DELETE,
                &path,
                &query,
                None::<&()>,
                Some("2021-07-28"),
            )
            .await
    }

    /// Get Price by ID for a Product
    ///
    /// The "Get Price by ID for a Product" API allows retrieving information for a specific
    /// price associated with a particular product using its unique identifier. Use this
    /// endpoint to fetch details for a single price based on the provided price ID and
    /// product ID.
    ///
    /// `GET /products/{productId}/price/{priceId}`
    ///
    /// Requires scope: `products/prices.readonly`.
    pub async fn get_price_by_id_for_a_product(
        &self,
        product_id: &str,
        price_id: &str,
        params: &GetPriceByIdForAProductParams,
    ) -> Result<models::GetPriceResponseDto> {
        let path = format!(
            "/products/{}/price/{}",
            crate::services::encode(product_id),
            crate::services::encode(price_id)
        );
        let query = params.to_query();
        self.client
            .send_versioned(
                reqwest::Method::GET,
                &path,
                &query,
                None::<&()>,
                Some("2021-07-28"),
            )
            .await
    }

    /// Update Price by ID for a Product
    ///
    /// The "Update Price by ID for a Product" API allows modifying information for a
    /// specific price associated with a particular product using its unique identifier. Use
    /// this endpoint to update details for a single price based on the provided price ID
    /// and product ID.
    ///
    /// `PUT /products/{productId}/price/{priceId}`
    ///
    /// Requires scope: `products/prices.write`.
    pub async fn update_price_by_id_for_a_product(
        &self,
        product_id: &str,
        price_id: &str,
        body: &models::UpdatePriceDto,
    ) -> Result<models::UpdatePriceResponseDto> {
        let path = format!(
            "/products/{}/price/{}",
            crate::services::encode(product_id),
            crate::services::encode(price_id)
        );
        let query = Vec::new();
        self.client
            .send_versioned(
                reqwest::Method::PUT,
                &path,
                &query,
                Some(body),
                Some("2021-07-28"),
            )
            .await
    }
}