Struct serenity::model::invite::Invite

#[non_exhaustive]
pub struct Invite {
    pub approximate_member_count: Option<u64>,
    pub approximate_presence_count: Option<u64>,
    pub code: String,
    pub channel: InviteChannel,
    pub guild: Option<InviteGuild>,
    pub inviter: Option<InviteUser>,
    pub target_type: Option<InviteTargetType>,
    pub target_user: Option<UserId>,
    pub target_application: Option<ApplicationId>,
    pub stage_instance: Option<InviteStageInstance>,
}

Information about an invite code.

Information can not be accessed for guilds the current user is banned from.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

approximate_member_count: Option<u64>

The approximate number of Members in the related Guild.

approximate_presence_count: Option<u64>

The approximate number of Members with an active session in the related Guild.

An active session is defined as an open, heartbeating WebSocket connection. These include invisible members.

code: String

The unique code for the invite.

channel: InviteChannel

A representation of the minimal amount of information needed about the GuildChannel being invited to.

guild: Option<InviteGuild>

A representation of the minimal amount of information needed about the Guild being invited to.

inviter: Option<InviteUser>

A representation of the minimal amount of information needed about the User that created the invite.

This can be None for invites created by Discord such as invite-widgets or vanity invite links.

target_type: Option<InviteTargetType>

The type of target for this voice channel invite.

target_user: Option<UserId>

The user whose stream to display for this voice channel stream invite.

Only shows up if target_type is Stream.

target_application: Option<ApplicationId>

The embedded application to open for this voice channel embedded application invite.

Only shows up if target_type is EmmbeddedApplication.

stage_instance: Option<InviteStageInstance>

The Stage instance data if there is a public Stage instance in the Stage channel this invite is for.

Implementations

impl Invite

pub async fn create<F>(
    cache_http: impl CacheHttp,
    channel_id: impl Into<ChannelId>,
    f: F
) -> Result<RichInvite> where
    F: FnOnce(CreateInvite) -> CreateInvite, 

Creates an invite for a GuildChannel, providing a builder so that fields may optionally be set.

See the documentation for the CreateInvite builder for information on how to use this and the default values that it provides.

Requires the Create Invite permission.

Errors

If the cache is enabled, returns a ModelError::InvalidPermissions if the current user does not have the required permission.

pub async fn delete(&self, cache_http: impl CacheHttp) -> Result<Invite>

Deletes the invite.

Note: Requires the Manage Guild permission.

Errors

If the cache is enabled, returns a ModelError::InvalidPermissions if the current user does not have the required permission.

Otherwise may return Error::Http if permissions are lacking, or if the invite is invalid.

pub async fn get(
    http: impl AsRef<Http>,
    code: &str,
    stats: bool
) -> Result<Invite>

Gets the information about an invite.

Errors

May return an Error::Http if the invite is invalid. Can also return an Error::Json if there is an error deserializing the API response.

pub fn url(&self) -> String

Returns a URL to use for the invite.

Examples

Retrieve the URL for an invite with the code WxZumR:

assert_eq!(invite.url(), "https://discord.gg/WxZumR");

Trait Implementations

impl Clone for Invite

fn clone(&self) -> Invite

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Invite

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Invite

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl Serialize for Invite

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.