Struct Channels

pub struct Channels {
    pub client: Client,
}

Fields

client: Client

Implementations

impl Channels

pub async fn list<'a>(&'a self) -> Result<ListChannelsResponse, Error>

List channels

List the channels of the company.

async fn example_channels_list() -> anyhow::Result<()> {
    let client = front_api::Client::new_from_env();
    let result: front_api::types::ListChannelsResponse = client.channels().list().await?;
    println!("{:?}", result);
    Ok(())
}

pub async fn list_team<'a>( &'a self, team_id: &'a str, ) -> Result<ListTeamChannelsResponse, Error>

List team channels

List the channels of a team.

Parameters:

• team_id: &'astr: The team ID (required)

async fn example_channels_list_team() -> anyhow::Result<()> {
    let client = front_api::Client::new_from_env();
    let result: front_api::types::ListTeamChannelsResponse =
        client.channels().list_team("some-string").await?;
    println!("{:?}", result);
    Ok(())
}

pub async fn list_teammate<'a>( &'a self, teammate_id: &'a str, ) -> Result<ListTeammateChannelsResponse, Error>

List teammate channels

List the channels of a teammate.

Parameters:

• teammate_id: &'astr: The teammate ID (required)

async fn example_channels_list_teammate() -> anyhow::Result<()> {
    let client = front_api::Client::new_from_env();
    let result: front_api::types::ListTeammateChannelsResponse =
        client.channels().list_teammate("some-string").await?;
    println!("{:?}", result);
    Ok(())
}

pub async fn get<'a>( &'a self, channel_id: &'a str, ) -> Result<ChannelResponse, Error>

Get channel

Fetch a channel.

Parameters:

• channel_id: &'astr: The Channel ID (required)

async fn example_channels_get() -> anyhow::Result<()> {
    let client = front_api::Client::new_from_env();
    let result: front_api::types::ChannelResponse = client.channels().get("some-string").await?;
    println!("{:?}", result);
    Ok(())
}

pub async fn update<'a>( &'a self, channel_id: &'a str, body: &UpdateChannel, ) -> Result<(), Error>

Update Channel

Update a channel.

Parameters:

• channel_id: &'astr: The Channel ID (required)

async fn example_channels_update() -> anyhow::Result<()> {
    let client = front_api::Client::new_from_env();
    client
        .channels()
        .update(
            "some-string",
            &serde_json::Value::String("some-string".to_string()),
        )
        .await?;
    Ok(())
}

pub async fn validate<'a>( &'a self, channel_id: &'a str, ) -> Result<ValidateChannelResponse, Error>

Validate channel

Asynchronously validate a channel

Parameters:

• channel_id: &'astr: The Channel ID (required)

async fn example_channels_validate() -> anyhow::Result<()> {
    let client = front_api::Client::new_from_env();
    let result: front_api::types::ValidateChannelResponse =
        client.channels().validate("some-string").await?;
    println!("{:?}", result);
    Ok(())
}

pub async fn create<'a>( &'a self, inbox_id: &'a str, body: &CreateChannel, ) -> Result<(), Error>

Create a channel

Create a channel in an inbox.

Parameters:

• inbox_id: &'astr: The Inbox ID (required)

async fn example_channels_create() -> anyhow::Result<()> {
    let client = front_api::Client::new_from_env();
    client
        .channels()
        .create(
            "some-string",
            &serde_json::Value::String("some-string".to_string()),
        )
        .await?;
    Ok(())
}

Trait Implementations

impl Clone for Channels

fn clone(&self) -> Channels

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Channels

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

Formats the value using the given formatter.