Struct Contacts

pub struct Contacts {
    pub client: Client,
}

Fields

client: Client

Implementations

impl Contacts

pub async fn list<'a>( &'a self, limit: Option<i64>, page_token: Option<String>, q: Option<String>, sort_by: Option<String>, sort_order: Option<SortOrder>, ) -> Result<ListContactsResponse, Error>

List contacts

List the contacts of the company.

Parameters:

• limit: Option<i64>: Max number of results per page
• page_token: Option<String>: Token to use to request the next page
• q: Option<String>: Search query object with the optional properties updated_after and updated_before, whose value should be a timestamp in seconds with up to 3 decimal places.
• sort_by: Option<String>: Field used to sort the records
• sort_order: Option<crate::types::SortOrder>: Order by which results should be sorted

async fn example_contacts_list() -> anyhow::Result<()> {
    let client = front_api::Client::new_from_env();
    let result: front_api::types::ListContactsResponse = client
        .contacts()
        .list(
            Some(4 as i64),
            Some("some-string".to_string()),
            Some("some-string".to_string()),
            Some("some-string".to_string()),
            Some(front_api::types::SortOrder::Asc),
        )
        .await?;
    println!("{:?}", result);
    Ok(())
}

pub async fn create<'a>( &'a self, body: &CreateContact, ) -> Result<ContactResponse, Error>

Create contact

Create a new contact.

async fn example_contacts_create() -> anyhow::Result<()> {
    let client = front_api::Client::new_from_env();
    let result: front_api::types::ContactResponse = client
        .contacts()
        .create(&front_api::types::CreateContact {
            name: Some("some-string".to_string()),
            description: Some("some-string".to_string()),
            avatar: Some(bytes::Bytes::from("some-string")),
            is_spammer: Some(true),
            links: Some(vec!["some-string".to_string()]),
            group_names: Some(vec!["some-string".to_string()]),
            custom_fields: Some(std::collections::HashMap::from([(
                "some-key".to_string(),
                "some-string".to_string(),
            )])),
            handles: Some(vec![front_api::types::ContactHandle {
                handle: "some-string".to_string(),
                source: front_api::types::Source::Intercom,
            }]),
        })
        .await?;
    println!("{:?}", result);
    Ok(())
}

pub async fn list_team<'a>( &'a self, limit: Option<i64>, page_token: Option<String>, q: Option<String>, sort_by: Option<String>, sort_order: Option<SortOrder>, team_id: &'a str, ) -> Result<ListTeamContactsResponse, Error>

List team contacts

List the contacts of a team.

Parameters:

• limit: Option<i64>: Max number of results per page
• page_token: Option<String>: Token to use to request the next page
• q: Option<String>: Search query object with the optional properties updated_after and updated_before, whose value should be a timestamp in seconds with up to 3 decimal places.
• sort_by: Option<String>: Field used to sort the records
• sort_order: Option<crate::types::SortOrder>: Order by which results should be sorted
• team_id: &'astr: The team ID (required)

async fn example_contacts_list_team() -> anyhow::Result<()> {
    let client = front_api::Client::new_from_env();
    let result: front_api::types::ListTeamContactsResponse = client
        .contacts()
        .list_team(
            Some(4 as i64),
            Some("some-string".to_string()),
            Some("some-string".to_string()),
            Some("some-string".to_string()),
            Some(front_api::types::SortOrder::Asc),
            "some-string",
        )
        .await?;
    println!("{:?}", result);
    Ok(())
}

pub async fn create_team<'a>( &'a self, team_id: &'a str, body: &CreateContact, ) -> Result<ContactResponse, Error>

Create team contact

Create a contact for a team.

Parameters:

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

async fn example_contacts_create_team() -> anyhow::Result<()> {
    let client = front_api::Client::new_from_env();
    let result: front_api::types::ContactResponse = client
        .contacts()
        .create_team(
            "some-string",
            &front_api::types::CreateContact {
                name: Some("some-string".to_string()),
                description: Some("some-string".to_string()),
                avatar: Some(bytes::Bytes::from("some-string")),
                is_spammer: Some(false),
                links: Some(vec!["some-string".to_string()]),
                group_names: Some(vec!["some-string".to_string()]),
                custom_fields: Some(std::collections::HashMap::from([(
                    "some-key".to_string(),
                    "some-string".to_string(),
                )])),
                handles: Some(vec![front_api::types::ContactHandle {
                    handle: "some-string".to_string(),
                    source: front_api::types::Source::Custom,
                }]),
            },
        )
        .await?;
    println!("{:?}", result);
    Ok(())
}

pub async fn list_teammate<'a>( &'a self, limit: Option<i64>, page_token: Option<String>, q: Option<String>, sort_by: Option<String>, sort_order: Option<SortOrder>, teammate_id: &'a str, ) -> Result<ListTeammateContactsResponse, Error>

List teammate contacts

List the contacts of a teammate.

Parameters:

• limit: Option<i64>: Max number of results per page
• page_token: Option<String>: Token to use to request the next page
• q: Option<String>: Search query object with the optional properties updated_after and updated_before, whose value should be a timestamp in seconds with up to 3 decimal places.
• sort_by: Option<String>: Field used to sort the records
• sort_order: Option<crate::types::SortOrder>: Order by which results should be sorted
• teammate_id: &'astr: The teammate ID (required)

async fn example_contacts_list_teammate() -> anyhow::Result<()> {
    let client = front_api::Client::new_from_env();
    let result: front_api::types::ListTeammateContactsResponse = client
        .contacts()
        .list_teammate(
            Some(4 as i64),
            Some("some-string".to_string()),
            Some("some-string".to_string()),
            Some("some-string".to_string()),
            Some(front_api::types::SortOrder::Asc),
            "some-string",
        )
        .await?;
    println!("{:?}", result);
    Ok(())
}

pub async fn create_teammate<'a>( &'a self, teammate_id: &'a str, body: &CreateContact, ) -> Result<ContactResponse, Error>

Create teammate contact

Create a contact for a teammate.

Parameters:

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

async fn example_contacts_create_teammate() -> anyhow::Result<()> {
    let client = front_api::Client::new_from_env();
    let result: front_api::types::ContactResponse = client
        .contacts()
        .create_teammate(
            "some-string",
            &front_api::types::CreateContact {
                name: Some("some-string".to_string()),
                description: Some("some-string".to_string()),
                avatar: Some(bytes::Bytes::from("some-string")),
                is_spammer: Some(false),
                links: Some(vec!["some-string".to_string()]),
                group_names: Some(vec!["some-string".to_string()]),
                custom_fields: Some(std::collections::HashMap::from([(
                    "some-key".to_string(),
                    "some-string".to_string(),
                )])),
                handles: Some(vec![front_api::types::ContactHandle {
                    handle: "some-string".to_string(),
                    source: front_api::types::Source::Twitter,
                }]),
            },
        )
        .await?;
    println!("{:?}", result);
    Ok(())
}

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

Get contact

Fetch a contact.

Parameters:

• contact_id: &'astr: The contact ID (required)

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

pub async fn delete<'a>(&'a self, contact_id: &'a str) -> Result<(), Error>

Delete a contact

Delete a contact.

Parameters:

• contact_id: &'astr: The contact ID (required)

async fn example_contacts_delete() -> anyhow::Result<()> {
    let client = front_api::Client::new_from_env();
    client.contacts().delete("some-string").await?;
    Ok(())
}

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

Update a contact

Updates a contact.

Parameters:

• contact_id: &'astr: The contact ID (required)

async fn example_contacts_update() -> anyhow::Result<()> {
    let client = front_api::Client::new_from_env();
    client
        .contacts()
        .update(
            "some-string",
            &front_api::types::Contact {
                name: Some("some-string".to_string()),
                description: Some("some-string".to_string()),
                avatar: Some(bytes::Bytes::from("some-string")),
                is_spammer: Some(true),
                links: Some(vec!["some-string".to_string()]),
                group_names: Some(vec!["some-string".to_string()]),
                custom_fields: Some(std::collections::HashMap::from([(
                    "some-key".to_string(),
                    "some-string".to_string(),
                )])),
            },
        )
        .await?;
    Ok(())
}

pub async fn merge<'a>( &'a self, body: &MergeContacts, ) -> Result<ContactResponse, Error>

Merge contacts

Merges the contacts specified into a single contact, deleting the merged-in contacts. If a target contact ID is supplied, the other contacts will be merged into that one. Otherwise, some contact in the contact ID list will be treated as the target contact. Merge conflicts will be resolved in the following ways:

• name will prioritize manually-updated and non-private contact names
• descriptions will be concatenated and separated by newlines in order from oldest to newest with the (optional) target contact’s description first
• all handles, groups, links, and notes will be preserved
• other conflicts will use the most recently updated contact’s value

async fn example_contacts_merge() -> anyhow::Result<()> {
    let client = front_api::Client::new_from_env();
    let result: front_api::types::ContactResponse = client
        .contacts()
        .merge(&serde_json::Value::String("some-string".to_string()))
        .await?;
    println!("{:?}", result);
    Ok(())
}

pub async fn list_conversations<'a>( &'a self, contact_id: &'a str, limit: Option<i64>, page_token: Option<String>, q: Option<String>, ) -> Result<ListContactConversationsResponse, Error>

List contact conversations

List the conversations for a contact in reverse chronological order (newest first). For more advanced filtering, see the search endpoint.

⚠️ Deprecated field included

This endpoint returns a deprecated last_message field in the top-level conversation bodies listed. Please use the _links.related.last_message field instead.

Parameters:

• contact_id: &'astr: The Contact ID (required)
• limit: Option<i64>: Max number of results per page
• page_token: Option<String>: Token to use to request the next page
• q: Option<String>: Search query object with a property statuses, whose value should be a list of conversation statuses (assigned, unassigned, archived, or deleted).

async fn example_contacts_list_conversations() -> anyhow::Result<()> {
    let client = front_api::Client::new_from_env();
    let result: front_api::types::ListContactConversationsResponse = client
        .contacts()
        .list_conversations(
            "some-string",
            Some(4 as i64),
            Some("some-string".to_string()),
            Some("some-string".to_string()),
        )
        .await?;
    println!("{:?}", result);
    Ok(())
}

Trait Implementations

impl Clone for Contacts

fn clone(&self) -> Contacts

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Contacts

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

Formats the value using the given formatter.