Struct jyve::request::stores_list_stats::StoresListStatsRequest

pub struct StoresListStatsRequest<'a> {

    pub address: Option<String>,
    pub brand_territory_brand_public_id: Option<String>,
    pub chain_name: Option<String>,
    pub city: Option<String>,
    pub county: Option<String>,
    pub ids: Option<String>,
    pub job_completed_range: Option<String>,
    pub job_ids: Option<String>,
    pub jyver_density_gte: Option<f64>,
    pub ordering: Option<String>,
    pub page: Option<i64>,
    pub page_size: Option<i64>,
    pub postal_code: Option<String>,
    pub primary_self_identity: Option<String>,
    pub q: Option<String>,
    pub state: Option<String>,
    pub store_chain: Option<f64>,
    pub store_chains: Option<String>,
    /* private fields */
}

Create this with the associated client method.

That method takes required values as arguments. Set optional values using builder methods on this struct.

Fields

address: Option<String>

brand_territory_brand_public_id: Option<String>

chain_name: Option<String>

city: Option<String>

county: Option<String>

ids: Option<String>

job_completed_range: Option<String>

job_ids: Option<String>

jyver_density_gte: Option<f64>

ordering: Option<String>

page: Option<i64>

page_size: Option<i64>

postal_code: Option<String>

primary_self_identity: Option<String>

q: Option<String>

state: Option<String>

store_chain: Option<f64>

store_chains: Option<String>

Implementations

impl<'a> StoresListStatsRequest<'a>

pub async fn send(self) -> InMemoryResult<Vec<Store>>

pub fn address(self, address: &str) -> Self

pub fn brand_territory_brand_public_id( self, brand_territory_brand_public_id: &str ) -> Self

pub fn chain_name(self, chain_name: &str) -> Self

pub fn city(self, city: &str) -> Self

pub fn county(self, county: &str) -> Self

pub fn ids(self, ids: &str) -> Self

pub fn job_completed_range(self, job_completed_range: &str) -> Self

pub fn job_ids(self, job_ids: &str) -> Self

pub fn jyver_density_gte(self, jyver_density_gte: f64) -> Self

pub fn ordering(self, ordering: &str) -> Self

pub fn page(self, page: i64) -> Self

pub fn page_size(self, page_size: i64) -> Self

pub fn postal_code(self, postal_code: &str) -> Self

pub fn primary_self_identity(self, primary_self_identity: &str) -> Self

pub fn q(self, q: &str) -> Self

pub fn state(self, state: &str) -> Self

pub fn store_chain(self, store_chain: f64) -> Self

pub fn store_chains(self, store_chains: &str) -> Self

Trait Implementations

impl<'a> Clone for StoresListStatsRequest<'a>

fn clone(&self) -> StoresListStatsRequest<'a>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> IntoFuture for StoresListStatsRequest<'a>

type Output = Result<Vec<Store, Global>, Error<Response<InMemoryBody>>>

The output that the future will produce on completion.

type IntoFuture = Pin<Box<dyn Future<Output = <StoresListStatsRequest<'a> as IntoFuture>::Output> + Send + 'a, Global>>

Which kind of future are we turning this into?

fn into_future(self) -> Self::IntoFuture

Creates a future from a value.