Struct GetClipsRequest 

pub struct GetClipsRequest<A>
where
    A: AuthToken,
{ /* private fields */ }

Request builder for the Get Clips endpoint

Implementations

impl<A> GetClipsRequest<A>

where A: AuthToken,

pub fn set_auth(&mut self, auth: A) -> &mut Self

Set the authorization token to be used with this request

pub fn set_broadcaster_id<S: Into<BroadcasterId>>(&mut self, id: S) -> &mut Self

Set the broadcaster_id request

Will replace current query type if already called set_game_id or add_clip_id

pub fn set_game_id<S: Into<GameId>>(&mut self, id: S) -> &mut Self

Set the game_id request

Will replace current query type if already called set_broadcaster_id or add_clip_id

pub fn add_clip_id<S: Into<ClipId>>(&mut self, id: S) -> &mut Self

Add a clip_id to search for

Will replace current query type if already called set_broadcaster_id or set_game_id

pub fn set_clip_ids<S>(&mut self, set: Vec<S>) -> &mut Self

where S: Into<ClipId>,

Replace the currect query with a specific set of game_ids

Will replace current query type if already called set_broadcaster_id or set_game_id

pub fn clear_clip_ids(&mut self) -> &mut Self

Clear the current query if it is of the type clip_id

pub fn set_count<C: Into<Count>>(&mut self, count: C) -> &mut Self

Sets the max amount of items to be returned from this request

Without being set this value is 20

pub fn reset_count(&mut self) -> &mut Self

Resets the amount of items to be returned from this request to its default of 20

pub fn set_period<S, T>(&mut self, started_at: S, ended_at: T) -> &mut Self

where S: Into<StartedAt>, T: Into<EndedAt>,

Set a time window filter, times are RFC3339

pub fn set_started_at<S>(&mut self, started_at: S) -> &mut Self

where S: Into<StartedAt>,

Set the start of the date/time window filter, if set_ended_at not called then the window ends a week from this value

pub fn set_ended_at<S: Into<EndedAt>>(&mut self, ended_at: S) -> &mut Self

Set the end of the date/time window filter, if set_started_at not called before this then it does nothing as and end may not be set without a start

pub fn before<P: Into<Pagination>>(&mut self, before: P) -> &mut Self

Set the backwards pagination cursor for this request, use with Pagination from previous response

pub fn after<P: Into<Pagination>>(&mut self, after: P) -> &mut Self

Set the forwards pagination cursor for this request, use with Pagination from previous response

Trait Implementations

impl<A> Debug for GetClipsRequest<A>

where A: AuthToken + Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<A> Request for GetClipsRequest<A>

where A: AuthToken + Sync,

const ENDPOINT: &'static str = "https://api.twitch.tv/helix/clips"

Endpoint where the request is made

const METHOD: Method = reqwest::Method::GET

The method that this request will use

type Headers = A

The type that represents the headers sent with this request

type Parameters = GetClipsRequest<A>

The type that represents the query parameters sent with this request

type Body = ()

The type that represents the body of this request

type Response = GetClipsResponse

The type returned by a sucessful request, must be DeserializeOwned and have at least a static lifetime (owned).

type ErrorCodes = CommonResponseCodes

The type that encapsulates the error codes that this endpoint can return, must have at least a static lifetime (owned).

fn builder() -> Self

Get a builder for this method

fn headers(&self) -> &Self::Headers

Get the Headers struct for this Request

fn parameters(&self) -> &Self::Parameters

Get the Parameters struct for this Request

fn body(&self) -> &Self::Body

Get the Body struct for this Request

fn ready(&self) -> Result<(), RequestError<Self::ErrorCodes>>

Must return Ok(()) if and only if this request is ready to have Self::make_request called on it.

fn make_request<'life0, 'async_trait, C>( &'life0 self, client: C, ) -> Pin<Box<dyn Future<Output = Result<Self::Response, RequestError<Self::ErrorCodes>>> + Send + 'async_trait>>

where C: Borrow<Client> + Send + 'async_trait, Self: Sync + 'async_trait, 'life0: 'async_trait,

Make the request represented by this object. Only makes request if Self::ready returns Ok(()).

impl<A> Serialize for GetClipsRequest<A>

where A: AuthToken,

fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<A> ParametersExt for GetClipsRequest<A>

where A: AuthToken,