Struct render_api::request::list_services::ListServicesRequest

pub struct ListServicesRequest<'a> {
    pub created_after: Option<String>,
    pub created_before: Option<String>,
    pub cursor: Option<String>,
    pub env: Option<String>,
    pub limit: Option<i64>,
    pub name: Option<String>,
    pub owner_id: Option<String>,
    pub region: Option<String>,
    pub suspended: Option<String>,
    pub type_: Option<String>,
    pub updated_after: Option<String>,
    pub updated_before: 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

created_after: Option<String>

created_before: Option<String>

cursor: Option<String>

env: Option<String>

limit: Option<i64>

name: Option<String>

owner_id: Option<String>

region: Option<String>

suspended: Option<String>

type_: Option<String>

updated_after: Option<String>

updated_before: Option<String>

Implementations

impl<'a> ListServicesRequest<'a>

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

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

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

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

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

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

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

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

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

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

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

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

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

Trait Implementations

impl<'a> Clone for ListServicesRequest<'a>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> IntoFuture for ListServicesRequest<'a>

type Output = Result<Vec<ServiceCursor, Global>, Error<InMemoryBody>>

The output that the future will produce on completion.

type IntoFuture = Pin<Box<dyn Future<Output = <ListServicesRequest<'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.