Groups - WhatsApp Rust

The Groups struct provides methods for managing WhatsApp groups, including creating groups, managing participants, and modifying group settings.

Access

Access group operations through the client:

let groups = client.groups();

Methods

query_info

Query group information with caching support.

query_info and get_metadata return different, purpose-built views of a group — pick based on what you’re doing with the result:

	`query_info`	`get_metadata`
Returns	`Arc<GroupInfo>` (slim)	`GroupMetadata` (full)
Fields	Participant JIDs, addressing mode, LID/PN mapping, CAG flag	Subject, description, admin roles, ephemeral/membership settings, and everything else
Cache	Cached; a hit is free, a miss sends the persisted phash so an unchanged group costs a `not-modified` reply	Always hits the network; no phash sent, no population of the group cache
Use for	Routing and encrypting a message (the send path’s own choice)	Displaying or auditing a group

Use query_info_with_freshness when you need explicit control over query_info’s staleness instead of the default cache-preferred behavior.

pub async fn query_info(&self, jid: &Jid) -> Result<Arc<GroupInfo>, GroupError>

Parameters:

jid - Group JID (must end with @g.us)

Returns:

Arc<GroupInfo> - Shared, reference-counted snapshot containing the participants list and addressing mode. Repeated calls for the same group return the same Arc from the in-memory cache, so warm sends avoid deep-cloning group metadata.

Example:

use std::sync::Arc;
use wacore::client::context::GroupInfo;

let group_jid: Jid = "123456789@g.us".parse()?;
let info: Arc<GroupInfo> = client.groups().query_info(&group_jid).await?;

println!("Participants: {}", info.participants.len());
println!("Addressing mode: {:?}", info.addressing_mode);

// Cheaply share the snapshot across tasks without copying participants.
let info_for_task = info.clone();
tokio::spawn(async move {
    println!("Participants in task: {}", info_for_task.participants.len());
});

`query_info_with_freshness`

Query group information with an explicit cache Freshness policy, instead of the always-cache-preferred behavior of query_info.

pub async fn query_info_with_freshness(
    &self,
    jid: &Jid,
    freshness: Freshness,
) -> Result<Arc<GroupInfo>, GroupError>

Parameters:

jid - Group JID (must end with @g.us)
freshness - Freshness::CachePreferred (same as query_info) or Freshness::Refresh to force a network round-trip

Returns:

Arc<GroupInfo> - Same shared snapshot type as query_info

A Refresh query leaves the currently cached snapshot readable to concurrent callers while the network request is in flight, then atomically replaces it once the response arrives — there is no window where the cache is empty. Example:

use whatsapp_rust::Freshness;

// Force a refresh after a notification implies the cached snapshot is stale.
let info = client
    .groups()
    .query_info_with_freshness(&group_jid, Freshness::Refresh)
    .await?;

get_participating

Get all groups the client is participating in.

pub async fn get_participating(&self) -> Result<HashMap<Jid, GroupMetadata>, GroupError>

Returns:

HashMap<Jid, GroupMetadata> - Map of group Jid to metadata

This map is keyed by Jid. Call .to_string() on the key if you need the string form.

GroupMetadata implements PartialEq and Eq, allowing direct comparison of group metadata instances. GroupMetadata fields:

id: Jid - Group JID
subject: String - Group name
notify: Option<String> - Display notification string reported by the server (from the notify attribute)
participants: Vec<GroupParticipant> - List of participants
addressing_mode: AddressingMode - Phone number or LID mode
creator: Option<Jid> - Group creator JID
creator_pn: Option<Jid> - Creator’s phone-number JID, when creator is a LID
creator_username: Option<String> - Creator’s Meta username, when present
creator_country_code: Option<String> - Creator’s ISO country code, when present
creation_time: Option<u64> - Group creation timestamp (Unix seconds)
participant_version_id: Option<String> - Participant-list version identifier (from p_v_id)
admin_version_id: Option<String> - Admin-list version identifier (from a_v_id)
open_thread_id: Option<String> - Open thread identifier associated with the group
has_missing_participant_identification: bool - Whether participant identity information was incomplete in this response
subject_time: Option<u64> - Subject modification timestamp (Unix seconds)
subject_owner: Option<Jid> - Subject owner JID
subject_owner_pn: Option<Jid> - Subject owner’s phone-number JID (from s_o_pn)
subject_owner_username: Option<String> - Subject owner’s Meta username (from s_o_username)
description: Option<String> - Group description body text
description_id: Option<String> - Description ID (for conflict detection)
description_owner: Option<Jid> - JID of the participant who set the description
description_owner_pn: Option<Jid> - Description owner’s phone-number JID
description_owner_username: Option<String> - Description owner’s Meta username
description_time: Option<u64> - Timestamp when the description was set (Unix seconds)
is_locked: bool - Whether only admins can edit group info
is_announcement: bool - Whether only admins can send messages
ephemeral: Option<GroupEphemeralSettings> - Disappearing-message settings. None when the server response has no <ephemeral> node at all; Some(GroupEphemeralSettings { expiration, trigger }) when the node is present — expiration is None if the node omitted the attribute, which is distinct from Some(0) (timer explicitly disabled)
membership_approval: bool - Whether admin approval is required to join
member_add_mode: Option<MemberAddMode> - Who can add members
member_link_mode: Option<MemberLinkMode> - Who can use invite links
size: Option<u32> - Total participant count
is_parent_group: bool - Whether this group is a community parent group
parent_membership_approval_required: bool - Whether joins to this parent group require approval by default
parent_group_jid: Option<Jid> - JID of the parent community (for subgroups)
is_default_sub_group: bool - Whether this is the default announcement subgroup of a community
is_general_chat: bool - Whether this is the general chat subgroup of a community
allow_non_admin_sub_group_creation: bool - Whether non-admin community members can create subgroups
no_frequently_forwarded: bool - Whether frequently-forwarded messages are restricted
member_share_history_mode: Option<MemberShareHistoryMode> - Who can share message history with new members
growth_locked: Option<GrowthLockInfo> - Growth lock status (invite links temporarily disabled by the system)
is_suspended: bool - Whether the group is suspended
suspension_can_auto_file: bool - Whether a suspension appeal may be filed automatically
appeal_status: Option<GroupAppealStatus> - Current suspension-appeal state
appeal_update_time: Option<u64> - Last suspension-appeal update timestamp (Unix seconds)
is_support_group: bool - Whether the group is marked as a support group
allow_admin_reports: bool - Whether admin reports are allowed
is_hidden_group: bool - Whether the group is hidden
is_incognito: bool - Whether incognito mode is enabled
has_group_history: bool - Whether group history is enabled
is_auto_add_disabled: bool - Whether automatic participant addition is disabled
has_capi: bool - Whether the group carries the CAPI capability marker
evolution_version: Option<u32> - Group schema evolution version
has_group_safety_check: bool - Whether the group safety-check feature is enabled
participant_label_enabled: bool - Whether participant labels are enabled
is_limit_sharing_enabled: bool - Whether limit sharing is enabled
limit_sharing_trigger: Option<u32> - Source trigger for limit-sharing enablement

ephemeral_expiration: u32 and ephemeral_trigger: Option<u32> were replaced by the single ephemeral: Option<GroupEphemeralSettings> field. Migrate reads like metadata.ephemeral_expiration to metadata.ephemeral.as_ref().and_then(|e| e.expiration).unwrap_or(0).

See Community API for community-specific operations. GroupParticipant implements PartialEq and Eq. GroupParticipant fields:

jid: Jid - Participant JID
phone_number: Option<Jid> - Phone number JID (for LID groups)
lid: Option<Jid> - Participant’s LID JID, when the server includes one
username: Option<CompactString> - Participant’s Meta username, when present
participant_type: ParticipantType - Participant role (member, admin, or super admin)
details: Option<Box<GroupParticipantDetails>> - Less-common participant metadata (label, join time, display name, etc.); boxed and only populated when at least one field is present

Example:

let groups = client.groups().get_participating().await?;

for (jid, metadata) in groups {
    println!("Group: {} ({})", metadata.subject, jid);
    println!("  Participants: {}", metadata.participants.len());
    
    for participant in &metadata.participants {
        println!("    {} ({:?})", participant.jid, participant.participant_type);
    }
}

get_metadata

Get metadata for a specific group.

pub async fn get_metadata(&self, jid: &Jid) -> Result<GroupMetadata, GroupError>

Parameters:

jid - Group JID

Returns:

GroupMetadata - Owned, full user-facing metadata: subject, description, creator, per-participant admin roles, and ephemeral/membership settings (see get_participating for the full field list). In a LID-addressed group, participant phone numbers the server left out are backfilled from known LID/PN mappings on a best-effort basis; a participant with no known mapping keeps phone_number: None.

The query always hits the network (no phash is sent, so the server never answers not-modified) and the result does not populate the group cache. Use this for displaying or auditing a group; when you only need the participant list to send a message, prefer the cached query_info. Example:

let group_jid: Jid = "123456789@g.us".parse()?;
let metadata = client.groups().get_metadata(&group_jid).await?;

println!("Subject: {}", metadata.subject);
println!("Mode: {:?}", metadata.addressing_mode);

create_group

Create a new group.

pub async fn create_group(
    &self,
    options: GroupCreateOptions,
) -> Result<CreateGroupResult, GroupError>

Parameters:

options: GroupCreateOptions - Group creation options
- subject: String - Group name (max 100 characters)
- participants: Vec<GroupParticipantOptions> - Initial participants
- member_link_mode: Option<MemberLinkMode> - Who can use invite links (default: AdminLink)
- member_add_mode: Option<MemberAddMode> - Who can add members (default: AllMemberAdd)
- membership_approval_mode: Option<MembershipApprovalMode> - Require admin approval (default: Off)
- ephemeral_expiration: Option<u32> - Disappearing messages timer in seconds (default: 0)
- is_parent: bool - Create as a community parent group (default: false)
- closed: bool - Whether the community requires approval to join. Only used when is_parent is true (default: false)
- allow_non_admin_sub_group_creation: bool - Allow non-admin members to create subgroups. Only used when is_parent is true (default: false)
- create_general_chat: bool - Create a general chat subgroup alongside the community. Only used when is_parent is true (default: false)
- linked_parent: Option<Jid> - Atomically link this group as a subgroup of an existing community on create. Mutually exclusive with is_parent — when set, the new group is always classified as a subgroup even if is_parent: true is also passed. (added in v0.6)
- description: Option<String> - Inline group description, emitted as a <description> child of the <create> stanza so it lands in one round-trip. Matches the existing community-create behavior. (added in v0.6)

Returns:

CreateGroupResult with a metadata: GroupMetadata field carrying the full server response (JID, subject, addressing mode, participants with display names, parent/community linkage, etc.).

When the PRIVACY_TOKEN_ON_GROUP_CREATE AB prop is enabled, the library automatically resolves and attaches privacy tokens (tc_token) to each participant during group creation. This is handled internally — you don’t need to manage tokens yourself. Example:

use whatsapp_rust::features::groups::{GroupCreateOptions, GroupParticipantOptions};

let participant1: Jid = "15551234567@s.whatsapp.net".parse()?;
let participant2: Jid = "15559876543@s.whatsapp.net".parse()?;

let options = GroupCreateOptions::builder()
    .subject("My New Group")
    .participants(vec![
        GroupParticipantOptions::new(participant1),
        GroupParticipantOptions::new(participant2),
    ])
    .build();

let result = client.groups().create_group(options).await?;
println!("Created group: {} ({})", result.metadata.subject, result.metadata.id);
for participant in &result.metadata.participants {
    println!("- {} ({:?})", participant.jid, participant.participant_type);
}

Since v0.6, create_group returns the full GroupMetadata (matching get_metadata) instead of just the JID. Inspect result.metadata for participants, addressing mode, ephemeral timer, and parent linkage in a single round-trip. GroupMetadata.participants is a Vec<GroupParticipant> (the IQ-response shape), not the GroupParticipantInfo used by group notification events — but masked-number display_name labels are available here too, via participant.details.as_ref().and_then(|d| d.display_name.as_deref()), in addition to the event-side GroupParticipantInfo.display_name for live group-update events.

set_subject

Change the group name.

pub async fn set_subject(&self, jid: &Jid, subject: GroupSubject) -> Result<(), GroupError>

Parameters:

jid - Group JID
subject - New group name (max 100 characters)

Example:

let group_jid: Jid = "123456789@g.us".parse()?;
let new_subject = GroupSubject::new("Updated Group Name")?;

client.groups().set_subject(&group_jid, new_subject).await?;

set_description

Set or delete the group description.

pub async fn set_description(
    &self,
    jid: impl Into<Jid>,
    description: Option<GroupDescription>,
    prev: PreviousDescription<'_>,
) -> Result<(), GroupError>

Parameters:

jid - Group JID
description - New description (max 2048 characters) or None to delete
prev - The description this update replaces, as a PreviousDescription. The server accepts the update only when this token matches the group’s current description id — a group that already has a description cannot be updated without it.

PreviousDescription::Resolve (the default) reads the current id from the server first, which always works but costs one extra query. If you already hold fresh GroupMetadata::description_id, pass it directly — metadata.description_id.as_deref().into() — to skip that query. Use PreviousDescription::Absent for a group you know has no description yet, such as one you just created.

Returns GroupError::DescriptionConflict if the group’s description changed on the server between the read and this update (for example, another device changed it first). Example:

use whatsapp_rust::features::groups::PreviousDescription;

let group_jid: Jid = "123456789@g.us".parse()?;
let desc = GroupDescription::new("This is our group chat")?;

// Resolves the current description id from the server automatically
client.groups().set_description(&group_jid, Some(desc), PreviousDescription::Resolve).await?;

// Skip the extra round trip with a token already on hand
let updated = GroupDescription::new("Updated topic")?;
let metadata = client.groups().get_metadata(&group_jid).await?;
client.groups()
    .set_description(&group_jid, Some(updated), metadata.description_id.as_deref().into())
    .await?;

// A freshly created group has no description yet
client.groups().set_description(&group_jid, Some(desc), PreviousDescription::Absent).await?;

// Delete description
client.groups().set_description(&group_jid, None, PreviousDescription::Resolve).await?;

leave

Leave a group.

pub async fn leave(&self, jid: &Jid) -> Result<(), GroupError>

Parameters:

jid - Group JID to leave

Example:

let group_jid: Jid = "123456789@g.us".parse()?;
client.groups().leave(&group_jid).await?;

add_participants

Add participants to a group.

pub async fn add_participants(
    &self,
    jid: &Jid,
    participants: &[Jid],
) -> Result<Vec<ParticipantChangeResponse>, GroupError>

Parameters:

jid - Group JID
participants - Array of participant JIDs to add

Returns:

Vec<ParticipantChangeResponse> - Result for each participant

When the PRIVACY_TOKEN_ON_GROUP_PARTICIPANT_ADD AB prop is enabled, the library automatically resolves and attaches privacy tokens (tc_token) to each participant. This is handled internally — you don’t need to manage tokens yourself. Example:

let group_jid: Jid = "123456789@g.us".parse()?;
let new_members = vec![
    "15551234567@s.whatsapp.net".parse()?,
    "15559876543@s.whatsapp.net".parse()?,
];

let results = client.groups().add_participants(&group_jid, &new_members).await?;

for result in results {
    println!("Added: {:?}", result);
}

remove_participants

Remove participants from a group.

pub async fn remove_participants(
    &self,
    jid: &Jid,
    participants: &[Jid],
) -> Result<Vec<ParticipantChangeResponse>, GroupError>

Parameters:

jid - Group JID
participants - Array of participant JIDs to remove

Returns:

Vec<ParticipantChangeResponse> - Result for each participant

Example:

let group_jid: Jid = "123456789@g.us".parse()?;
let to_remove = vec!["15551234567@s.whatsapp.net".parse()?];

client.groups().remove_participants(&group_jid, &to_remove).await?;

remove_participants_including_linked_groups

Remove participants from a group and cascade the removal to its linked/child groups. Used for community-linked groups, where removing someone from the community should also remove them from subgroups.

pub async fn remove_participants_including_linked_groups(
    &self,
    jid: &Jid,
    participants: &[Jid],
) -> Result<Vec<ParticipantChangeResponse>, GroupError>

Parameters:

jid - Group JID (typically the community parent group)
participants - Array of participant JIDs to remove

Returns:

Vec<ParticipantChangeResponse> - Result for each participant

Example:

let group_jid: Jid = "123456789@g.us".parse()?;
let to_remove = vec!["15551234567@s.whatsapp.net".parse()?];

let results = client.groups().remove_participants_including_linked_groups(&group_jid, &to_remove).await?;

promote_participants

Promote participants to admin.

pub async fn promote_participants(
    &self,
    jid: &Jid,
    participants: &[Jid],
) -> Result<Vec<ParticipantChangeResponse>, GroupError>

Parameters:

jid - Group JID
participants - Array of participant JIDs to promote

Returns:

Vec<ParticipantChangeResponse> - Result for each participant

Example:

let group_jid: Jid = "123456789@g.us".parse()?;
let to_promote = vec!["15551234567@s.whatsapp.net".parse()?];

let results = client.groups().promote_participants(&group_jid, &to_promote).await?;

for result in results {
    println!("Promoted {}: status {:?}", result.jid, result.status);
}

promote_participants returns Vec<ParticipantChangeResponse> (one entry per participant) instead of ().

demote_participants

Demote admin participants to regular members.

pub async fn demote_participants(
    &self,
    jid: &Jid,
    participants: &[Jid],
) -> Result<Vec<ParticipantChangeResponse>, GroupError>

Parameters:

jid - Group JID
participants - Array of admin JIDs to demote

Returns:

Vec<ParticipantChangeResponse> - Result for each participant

Example:

let group_jid: Jid = "123456789@g.us".parse()?;
let to_demote = vec!["15551234567@s.whatsapp.net".parse()?];

let results = client.groups().demote_participants(&group_jid, &to_demote).await?;

for result in results {
    println!("Demoted {}: status {:?}", result.jid, result.status);
}

demote_participants returns Vec<ParticipantChangeResponse> (one entry per participant) instead of ().

get_invite_link

Get or reset the group invite link.

pub async fn get_invite_link(&self, jid: &Jid, reset: bool) -> Result<String, GroupError>

Parameters:

jid - Group JID
reset - Whether to reset and generate a new invite link

Returns:

String - Invite link code

Example:

let group_jid: Jid = "123456789@g.us".parse()?;

// Get current invite link
let link = client.groups().get_invite_link(&group_jid, false).await?;
println!("Invite link: https://chat.whatsapp.com/{}", link);

// Reset and get new link
let new_link = client.groups().get_invite_link(&group_jid, true).await?;
println!("New invite link: https://chat.whatsapp.com/{}", new_link);

join_with_invite_code

Join a group using an invite code or full invite URL.

pub async fn join_with_invite_code(&self, code: &str) -> Result<JoinGroupResult, GroupError>

Parameters:

code - Invite code or full URL (e.g., "AbCdEfGh" or "https://chat.whatsapp.com/AbCdEfGh")

Returns:

JoinGroupResult - Either Joined(Jid) if immediately joined, or PendingApproval(Jid) if the group requires admin approval

Example:

use whatsapp_rust::features::groups::JoinGroupResult;

// Join using a full URL or just the code
let result = client.groups().join_with_invite_code("https://chat.whatsapp.com/AbCdEfGh").await?;

match &result {
    JoinGroupResult::Joined(jid) => println!("Joined group: {}", jid),
    JoinGroupResult::PendingApproval(jid) => println!("Pending approval for group: {}", jid),
}

// Access the group JID regardless of result
println!("Group JID: {}", result.group_jid());

join_with_invite_v4

Accept a V4 group invite received as a GroupInviteMessage (not a link). V4 invites are sent directly by a group admin as a message, rather than shared as a URL.

pub async fn join_with_invite_v4(
    &self,
    group_jid: &Jid,
    code: &str,
    expiration: i64,
    admin_jid: &Jid,
) -> Result<JoinGroupResult, GroupError>

Parameters:

group_jid - The target group JID
code - Invite code from the GroupInviteMessage
expiration - Invite expiration timestamp (Unix seconds). The method returns an error if the invite has expired.
admin_jid - JID of the admin who sent the invite

Returns:

JoinGroupResult - Either Joined(Jid) if immediately joined, or PendingApproval(Jid) if the group requires admin approval

Example:

use whatsapp_rust::features::groups::JoinGroupResult;

let group_jid: Jid = "123456789@g.us".parse()?;
let admin_jid: Jid = "15551234567@s.whatsapp.net".parse()?;

let result = client.groups().join_with_invite_v4(
    &group_jid,
    "AbCdEfGh",
    1735689600,    // expiration timestamp
    &admin_jid,
).await?;

match &result {
    JoinGroupResult::Joined(jid) => println!("Joined group: {}", jid),
    JoinGroupResult::PendingApproval(jid) => println!("Pending approval for group: {}", jid),
}

V4 invites expire. The method automatically checks the expiration timestamp and returns an error if the invite has already expired. You can pass 0 as the expiration to skip the expiration check.

get_invite_info

Get group metadata from an invite code without joining the group.

pub async fn get_invite_info(&self, code: &str) -> Result<GroupMetadata, GroupError>

Parameters:

code - Invite code or full URL

Returns:

GroupMetadata - Group metadata (see get_participating for fields)

Example:

// Preview a group before joining
let metadata = client.groups().get_invite_info("AbCdEfGh").await?;

println!("Group: {}", metadata.subject);
println!("Participants: {}", metadata.participants.len());
println!("Approval required: {}", metadata.membership_approval);

set_locked

Lock or unlock the group so only admins can change group info.

pub async fn set_locked(&self, jid: &Jid, locked: bool) -> Result<(), GroupError>

Parameters:

jid - Group JID
locked - true to lock (only admins edit info), false to unlock

Example:

let group_jid: Jid = "123456789@g.us".parse()?;

// Lock group info
client.groups().set_locked(&group_jid, true).await?;

// Unlock group info
client.groups().set_locked(&group_jid, false).await?;

set_announce

Set announcement mode. When enabled, only admins can send messages.

pub async fn set_announce(&self, jid: &Jid, announce: bool) -> Result<(), GroupError>

Parameters:

jid - Group JID
announce - true to enable (only admins send), false to disable

Example:

let group_jid: Jid = "123456789@g.us".parse()?;

// Enable announcement mode
client.groups().set_announce(&group_jid, true).await?;

// Disable announcement mode
client.groups().set_announce(&group_jid, false).await?;

set_ephemeral

Set the disappearing messages timer on the group.

pub async fn set_ephemeral(&self, jid: &Jid, expiration: u32) -> Result<(), GroupError>

Parameters:

jid - Group JID
expiration - Timer duration in seconds. Common values: 86400 (24 hours), 604800 (7 days), 7776000 (90 days). Pass 0 to disable.

Example:

let group_jid: Jid = "123456789@g.us".parse()?;

// Enable 7-day disappearing messages
client.groups().set_ephemeral(&group_jid, 604800).await?;

// Disable disappearing messages
client.groups().set_ephemeral(&group_jid, 0).await?;

set_membership_approval

Set membership approval mode. When enabled, new members must be approved by an admin.

pub async fn set_membership_approval(
    &self,
    jid: &Jid,
    mode: MembershipApprovalMode,
) -> Result<(), GroupError>

Parameters:

jid - Group JID
mode - MembershipApprovalMode::On to require approval, MembershipApprovalMode::Off to disable

Example:

use whatsapp_rust::features::groups::MembershipApprovalMode;

let group_jid: Jid = "123456789@g.us".parse()?;

// Require admin approval
client.groups().set_membership_approval(&group_jid, MembershipApprovalMode::On).await?;

// Remove approval requirement
client.groups().set_membership_approval(&group_jid, MembershipApprovalMode::Off).await?;

get_membership_requests

Get pending membership approval requests for a group.

pub async fn get_membership_requests(
    &self,
    jid: &Jid,
) -> Result<Vec<MembershipRequest>, GroupError>

Parameters:

jid - Group JID

Returns:

Vec<MembershipRequest> - List of pending requests

Example:

let group_jid: Jid = "123456789@g.us".parse()?;
let requests = client.groups().get_membership_requests(&group_jid).await?;

for request in &requests {
    println!("Pending request from: {}", request.jid);
    if let Some(time) = request.request_time {
        println!("  Requested at: {}", time);
    }
}

approve_membership_requests

Approve pending membership requests for a group.

pub async fn approve_membership_requests(
    &self,
    jid: &Jid,
    participants: &[Jid],
) -> Result<Vec<ParticipantChangeResponse>, GroupError>

Parameters:

jid - Group JID
participants - Array of JIDs to approve

Returns:

Vec<ParticipantChangeResponse> - Result for each participant

Example:

let group_jid: Jid = "123456789@g.us".parse()?;

// Get pending requests
let requests = client.groups().get_membership_requests(&group_jid).await?;
let jids: Vec<Jid> = requests.iter().map(|r| r.jid.clone()).collect();

// Approve all pending requests
let results = client.groups().approve_membership_requests(&group_jid, &jids).await?;

for result in results {
    println!("Approved {}: status {:?}", result.jid, result.status);
}

reject_membership_requests

Reject pending membership requests for a group.

pub async fn reject_membership_requests(
    &self,
    jid: &Jid,
    participants: &[Jid],
) -> Result<Vec<ParticipantChangeResponse>, GroupError>

Parameters:

jid - Group JID
participants - Array of JIDs to reject

Returns:

Vec<ParticipantChangeResponse> - Result for each participant

Example:

let group_jid: Jid = "123456789@g.us".parse()?;
let to_reject = vec!["15551234567@s.whatsapp.net".parse()?];

let results = client.groups().reject_membership_requests(&group_jid, &to_reject).await?;

set_member_add_mode

Set who can add members to the group.

pub async fn set_member_add_mode(
    &self,
    jid: &Jid,
    mode: MemberAddMode,
) -> Result<(), GroupError>

Parameters:

jid - Group JID
mode - MemberAddMode::AdminAdd to restrict to admins, MemberAddMode::AllMemberAdd to allow all members

Example:

use whatsapp_rust::features::groups::MemberAddMode;

let group_jid: Jid = "123456789@g.us".parse()?;

// Only admins can add members
client.groups().set_member_add_mode(&group_jid, MemberAddMode::AdminAdd).await?;

// All members can add others
client.groups().set_member_add_mode(&group_jid, MemberAddMode::AllMemberAdd).await?;

set_no_frequently_forwarded

Restrict or allow frequently-forwarded messages in the group.

pub async fn set_no_frequently_forwarded(
    &self,
    jid: &Jid,
    restrict: bool,
) -> Result<(), GroupError>

Parameters:

jid - Group JID
restrict - true to restrict frequently-forwarded messages, false to allow them

Example:

let group_jid: Jid = "123456789@g.us".parse()?;

// Restrict frequently-forwarded messages
client.groups().set_no_frequently_forwarded(&group_jid, true).await?;

// Allow frequently-forwarded messages
client.groups().set_no_frequently_forwarded(&group_jid, false).await?;

set_allow_admin_reports

Enable or disable admin reports in the group.

pub async fn set_allow_admin_reports(
    &self,
    jid: &Jid,
    allow: bool,
) -> Result<(), GroupError>

Parameters:

jid - Group JID
allow - true to enable admin reports, false to disable

Example:

let group_jid: Jid = "123456789@g.us".parse()?;

// Enable admin reports
client.groups().set_allow_admin_reports(&group_jid, true).await?;

// Disable admin reports
client.groups().set_allow_admin_reports(&group_jid, false).await?;

set_group_history

Enable or disable group history sharing.

pub async fn set_group_history(&self, jid: &Jid, enabled: bool) -> Result<(), GroupError>

Parameters:

jid - Group JID
enabled - true to enable group history, false to disable

Example:

let group_jid: Jid = "123456789@g.us".parse()?;

// Enable group history
client.groups().set_group_history(&group_jid, true).await?;

// Disable group history
client.groups().set_group_history(&group_jid, false).await?;

set_member_link_mode

Set who can share invite links. This uses the MEX (Mutation Exchange) protocol.

pub async fn set_member_link_mode(
    &self,
    jid: &Jid,
    mode: MemberLinkMode,
) -> Result<(), GroupError>

Parameters:

jid - Group JID
mode - MemberLinkMode::AdminLink to restrict to admins, MemberLinkMode::AllMemberLink to allow all members

Example:

use whatsapp_rust::features::groups::MemberLinkMode;

let group_jid: Jid = "123456789@g.us".parse()?;

// Only admins can share invite links
client.groups().set_member_link_mode(&group_jid, MemberLinkMode::AdminLink).await?;

// All members can share invite links
client.groups().set_member_link_mode(&group_jid, MemberLinkMode::AllMemberLink).await?;

set_member_share_history_mode

Set who can share message history with new members. This uses the MEX protocol.

pub async fn set_member_share_history_mode(
    &self,
    jid: &Jid,
    mode: MemberShareHistoryMode,
) -> Result<(), GroupError>

Parameters:

jid - Group JID
mode - MemberShareHistoryMode::AdminShare to restrict to admins, MemberShareHistoryMode::AllMemberShare to allow all members

Example:

use whatsapp_rust::features::groups::MemberShareHistoryMode;

let group_jid: Jid = "123456789@g.us".parse()?;

// Only admins can share history with new members
client.groups().set_member_share_history_mode(
    &group_jid,
    MemberShareHistoryMode::AdminShare,
).await?;

// All members can share history
client.groups().set_member_share_history_mode(
    &group_jid,
    MemberShareHistoryMode::AllMemberShare,
).await?;

set_limit_sharing

Enable or disable limit sharing in the group. This uses the MEX protocol.

pub async fn set_limit_sharing(&self, jid: &Jid, enabled: bool) -> Result<(), GroupError>

Parameters:

jid - Group JID
enabled - true to enable limit sharing, false to disable

Example:

let group_jid: Jid = "123456789@g.us".parse()?;

// Enable limit sharing
client.groups().set_limit_sharing(&group_jid, true).await?;

// Disable limit sharing
client.groups().set_limit_sharing(&group_jid, false).await?;

cancel_membership_requests

Cancel pending membership requests from the requesting user’s side.

pub async fn cancel_membership_requests(
    &self,
    jid: &Jid,
    participants: &[Jid],
) -> Result<Vec<ParticipantChangeResponse>, GroupError>

Parameters:

jid - Group JID
participants - Array of JIDs whose pending requests to cancel

Returns:

Vec<ParticipantChangeResponse> - Result for each participant

Example:

let group_jid: Jid = "123456789@g.us".parse()?;
let to_cancel = vec!["15551234567@s.whatsapp.net".parse()?];

let results = client.groups().cancel_membership_requests(&group_jid, &to_cancel).await?;

revoke_request_code

Revoke invitation codes from specific participants. This is an admin operation.

pub async fn revoke_request_code(
    &self,
    jid: &Jid,
    participants: &[Jid],
) -> Result<Vec<ParticipantChangeResponse>, GroupError>

Parameters:

jid - Group JID
participants - Array of participant JIDs whose invitation codes to revoke

Returns:

Vec<ParticipantChangeResponse> - Result for each participant

Example:

let group_jid: Jid = "123456789@g.us".parse()?;
let to_revoke = vec!["15551234567@s.whatsapp.net".parse()?];

let results = client.groups().revoke_request_code(&group_jid, &to_revoke).await?;

acknowledge

Acknowledge a group notification.

pub async fn acknowledge(&self, jid: &Jid) -> Result<(), GroupError>

Parameters:

jid - Group JID

Example:

let group_jid: Jid = "123456789@g.us".parse()?;
client.groups().acknowledge(&group_jid).await?;

update_member_label_with_id

Set or clear the bot’s per-group member label, sent as a ProtocolMessage over the normal message path (not an IQ). Returns the sent stanza’s message ID.

pub async fn update_member_label_with_id(
    &self,
    group_jid: &Jid,
    label: impl Into<String>,
) -> Result<String, GroupError>

Parameters:

group_jid - Group JID
label - New label text, or an empty string to clear the label

Returns:

String - Message ID of the sent stanza

Example:

let group_jid: Jid = "123456789@g.us".parse()?;
let message_id = client.groups().update_member_label_with_id(&group_jid, "VIP").await?;
println!("Label update sent as message {}", message_id);

update_member_label is a thin wrapper around update_member_label_with_id that discards the message ID and returns Result<(), GroupError>, for callers that don’t need it.

batch_get_info

Batch query group info for multiple groups at once.

pub async fn batch_get_info(
    &self,
    jids: Vec<Jid>,
) -> Result<Vec<BatchGroupResult>, GroupError>

Parameters:

jids - List of group JIDs to query (max 10,000)

Returns:

Vec<BatchGroupResult> - Result for each group

Example:

use whatsapp_rust::features::groups::BatchGroupResult;

let group_jids: Vec<Jid> = vec![
    "120363012345678@g.us".parse()?,
    "120363087654321@g.us".parse()?,
];

let results = client.groups().batch_get_info(group_jids).await?;

for result in results {
    match result {
        BatchGroupResult::Full(metadata) => {
            println!("Group: {} - {}", metadata.id, metadata.subject);
        }
        BatchGroupResult::Truncated { id, size } => {
            println!("Truncated: {} (size: {:?})", id, size);
        }
        BatchGroupResult::Forbidden(id) => {
            println!("Forbidden: {}", id);
        }
        BatchGroupResult::NotFound(id) => {
            println!("Not found: {}", id);
        }
    }
}

set_profile_picture

Set a group’s profile picture. Admin operation.

pub async fn set_profile_picture(
    &self,
    group_jid: &Jid,
    image_data: Vec<u8>,
) -> Result<SetProfilePictureResponse, GroupError>

Parameters:

group_jid - Group JID (must end with @g.us)
image_data - JPEG image bytes. The caller is responsible for sizing/cropping the image (WhatsApp uses 640x640).

Returns:

SetProfilePictureResponse - Contains the new picture ID

Passing empty image_data routes to removal, mirroring the own-picture API. Prefer remove_profile_picture when removal is the intent. Example:

use std::fs;

let group_jid: Jid = "120363012345678@g.us".parse()?;
let image_bytes = fs::read("group_avatar.jpg")?;

let response = client.groups().set_profile_picture(&group_jid, image_bytes).await?;
if let Some(id) = response.id {
    println!("Group picture updated: {}", id);
}

The image must be a valid JPEG. Other formats are not supported. The caller must be a group admin.

remove_profile_picture

Remove a group’s profile picture. Admin operation.

pub async fn remove_profile_picture(
    &self,
    group_jid: &Jid,
) -> Result<SetProfilePictureResponse, GroupError>

Parameters:

group_jid - Group JID

Returns:

SetProfilePictureResponse - Confirmation of removal

Example:

let group_jid: Jid = "120363012345678@g.us".parse()?;
client.groups().remove_profile_picture(&group_jid).await?;

See SetProfilePictureResponse for the response shape.

get_profile_pictures

Batch fetch group profile pictures.

pub async fn get_profile_pictures(
    &self,
    group_jids: Vec<Jid>,
    picture_type: PictureType,
) -> Result<Vec<GroupProfilePicture>, GroupError>

Parameters:

group_jids - List of group JIDs (max 1,000)
picture_type - PictureType::Preview for thumbnails or PictureType::Image for full-size

Returns:

Vec<GroupProfilePicture> - Profile picture data for each group

Example:

use whatsapp_rust::features::groups::{PictureType, GroupProfilePicture};

let group_jids: Vec<Jid> = vec![
    "120363012345678@g.us".parse()?,
    "120363087654321@g.us".parse()?,
];

let pictures = client.groups().get_profile_pictures(group_jids, PictureType::Preview).await?;

for pic in pictures {
    if let Some(url) = &pic.url {
        println!("Group {}: {}", pic.group_jid, url);
    }
}

Types

`Freshness`

Selects whether an operation may return an existing cached snapshot or must consult its source before returning. Shared across the SDK wherever a cache-backed lookup accepts an explicit staleness policy — Groups::query_info_with_freshness here, and StatusSendOptions::device_freshness (see Status).

#[non_exhaustive]
pub enum Freshness {
    /// Return a cached snapshot when available and consult the source on a miss (default).
    CachePreferred,
    /// Consult the source and publish the resulting snapshot without clearing the
    /// previous one first.
    Refresh,
}

Freshness is re-exported from the crate root, so you can import it directly: use whatsapp_rust::Freshness;. When you pass Refresh, you never see a caller-visible gap — the previous snapshot stays servable until the new one is published.

GroupInfo

Cached group information returned by query_info. Contains participant list, addressing mode, and LID-to-phone mappings for privacy-addressed groups. query_info returns Arc<GroupInfo> so that repeated lookups and warm sends share the same snapshot without deep-cloning the participants list.

pub struct GroupInfo {
    pub participants: Vec<Jid>,
    pub addressing_mode: AddressingMode,
}

Methods:

Method	Description
`phone_jid_for_lid_user(lid_user: &str) -> Option<&Jid>`	Look up the phone JID for a LID user
`lid_user_for_phone_user(phone_user: &str) -> Option<&CompactString>`	Look up the LID user string for a phone number
`phone_device_jid_to_lid(phone_device_jid: &Jid) -> Jid`	Convert a phone-based device JID to LID format

Example:

let info = client.groups().query_info(&group_jid).await?; // Arc<GroupInfo>

// Access participants and addressing mode
for participant in &info.participants {
    println!("Participant: {}", participant);
}

// For LID-addressed groups, resolve phone numbers
if info.addressing_mode == AddressingMode::Lid {
    if let Some(phone_jid) = info.phone_jid_for_lid_user("lid_user_id") {
        println!("Phone: {}", phone_jid);
    }
}

GroupSubject

Validated group name with 100 character limit.

impl GroupSubject {
    pub fn new(subject: impl Into<String>) -> Result<Self, anyhow::Error>
    pub fn into_string(self) -> String
}

GroupDescription

Validated group description with 2048 character limit.

impl GroupDescription {
    pub fn new(description: impl Into<String>) -> Result<Self, anyhow::Error>
    pub fn into_string(self) -> String
}

PreviousDescription

The description a set_description call expects to replace — the server’s optimistic-concurrency token for the group’s description.

pub enum PreviousDescription<'a> {
    Resolve,      // default
    Absent,
    Id(&'a str),
}

impl<'a> From<Option<&'a str>> for PreviousDescription<'a>

Resolve (default) — read the group’s current description id from the server before sending. The only variant that’s correct without knowing anything about the group, and the only one that costs a round trip.
Absent — the group carries no description yet (e.g. one you just created), so no token is sent.
Id(&str) — a description id you already hold, typically GroupMetadata::description_id from a recent get_metadata call.

From<Option<&str>> lets you turn a held GroupMetadata::description_id into a token directly: None maps to Absent (that metadata says the group has no description), Some(id) maps to Id(id). Use Resolve instead when the metadata’s age is unknown, since stale metadata that missed a description added since would otherwise surface as GroupError::DescriptionConflict.

GroupEphemeralSettings

Disappearing-message settings carried by a group’s <ephemeral> node.

pub struct GroupEphemeralSettings {
    pub expiration: Option<u32>,
    pub trigger: Option<u32>,
}

MemberAddMode

pub enum MemberAddMode {
    AdminAdd,      // Only admins can add members
    AllMemberAdd,  // All members can add
}

ParticipantType

Participant role within a group.

pub enum ParticipantType {
    Member,     // Regular member
    Admin,      // Group admin
    SuperAdmin, // Group creator / super admin
}

Methods:

is_admin(&self) -> bool - Returns true if admin or super admin

GroupParticipantDetails

Less-common participant metadata. Boxed on GroupParticipant/GroupParticipantResponse and only populated when at least one field is present.

#[non_exhaustive]
pub struct GroupParticipantDetails {
    pub participant_label: Option<CompactString>,
    pub participant_label_mtime: Option<u64>,
    pub join_time: Option<u64>,
    pub group_history_sent: Option<bool>,
    pub display_name: Option<CompactString>,
    pub is_addressable: bool,
}

GroupParticipantDetails is #[non_exhaustive]. Field reads are unaffected; only exhaustive struct destructuring from outside the crate requires adding ...

MemberLinkMode

Controls who can use invite links to join the group.

pub enum MemberLinkMode {
    AdminLink,      // Only admins can share invite links
    AllMemberLink,  // All members can share invite links
}

MemberShareHistoryMode

Controls who can share message history with new members.

pub enum MemberShareHistoryMode {
    AdminShare,      // Only admins can share history
    AllMemberShare,  // All members can share history
}

MembershipApprovalMode

pub enum MembershipApprovalMode {
    Off,  // No approval required
    On,   // Admin approval required
}

GroupAppealStatus

Review state for an appeal on a suspended group.

pub enum GroupAppealStatus {
    Approved,
    InReview,
    NoAppeal,
    Rejected,
}

GroupParticipantOptions

Options for specifying a participant when creating or modifying a group.

pub struct GroupParticipantOptions {
    pub jid: Jid,
    pub phone_number: Option<Jid>,
    pub privacy: Option<Vec<u8>>,
}

Constructors:

GroupParticipantOptions::new(jid) - Create from a JID
GroupParticipantOptions::from_phone(phone_number) - Create from a phone number JID
GroupParticipantOptions::from_lid_and_phone(lid, phone_number) - Create from a LID and phone number

Builder methods:

.with_phone_number(jid) - Attach a phone number JID (for LID participants)
.with_privacy(token) - Attach a privacy token (tc_token bytes)

You typically don’t need to set the privacy field manually. When AB props are enabled, the library automatically resolves and attaches privacy tokens during create_group and add_participants operations.

Example:

use whatsapp_rust::features::groups::GroupParticipantOptions;

let participant = GroupParticipantOptions::new("15551234567@s.whatsapp.net".parse()?);

JoinGroupResult

Result of joining a group via invite code.

pub enum JoinGroupResult {
    Joined(Jid),          // Successfully joined
    PendingApproval(Jid), // Membership approval required
}

Methods:

group_jid(&self) -> &Jid - Returns the group JID regardless of result variant

MembershipRequest

A pending membership approval request.

pub struct MembershipRequest {
    pub jid: Jid,
    pub request_time: Option<u64>,
}

ParticipantChangeResponse

Result of a participant change operation (add, remove, approve, reject).

#[non_exhaustive]
pub struct ParticipantChangeResponse {
    pub jid: Jid,
    pub status: Option<String>,
    pub error: Option<String>,
    pub add_request: Option<AddRequestInfo>,
}

ParticipantChangeResponse is #[non_exhaustive]. Field reads are unaffected; only exhaustive struct destructuring from outside the crate requires adding ...

add_request is populated when the server responds with HTTP 403 carrying an <add_request> child — that happens when a participant has privacy blocked direct adds and the inviter must send them a v4 invite link out-of-band. Since v0.6 the value is preserved instead of being dropped, so consumers can drive the v4 invite flow without parsing the raw IQ.

pub struct AddRequestInfo {
    pub code: String,        // v4 invite token
    pub expiration: i64,     // unix seconds; 0 means the server omitted it
}

AddressingMode

pub enum AddressingMode {
    Pn,   // Phone number addressing
    Lid,  // LID (privacy) addressing
}

BatchGroupResult

Result for a single group in a batch query.

pub enum BatchGroupResult {
    Full(Box<GroupMetadata>),           // Full group metadata
    Truncated { id: Jid, size: Option<u32> },  // Only ID and size returned
    Forbidden(Jid),                     // Access denied
    NotFound(Jid),                      // Group does not exist
}

GrowthLockInfo

Growth lock information (system-managed, read-only). When present, invite links are temporarily disabled by the system.

pub struct GrowthLockInfo {
    pub lock_type: String,
    pub expiration: u64,
}

PictureType

Profile picture query type for batch fetching.

pub enum PictureType {
    Preview,  // Thumbnail / preview size
    Image,    // Full-size image
}

GroupProfilePicture

A single group profile picture result from a batch query.

pub struct GroupProfilePicture {
    pub group_jid: Jid,
    pub url: Option<String>,
    pub direct_path: Option<String>,
    pub photo_id: Option<String>,
}

CreateGroupResult

Result of creating a group.

#[non_exhaustive]
pub struct CreateGroupResult {
    pub metadata: GroupMetadata,
}

CreateGroupResult is #[non_exhaustive]. Field reads are unaffected; only exhaustive struct destructuring from outside the crate requires adding ...

The metadata field carries the full group state returned by the server (same shape as get_metadata). metadata.participants is Vec<GroupParticipant> — masked-number display_name labels are reachable via participant.details.as_ref().and_then(|d| d.display_name.as_deref()), or from the event-side GroupParticipantInfo (which carries <participant> children of notification events) when handling live group-update events.

Prior to v0.6 this struct only exposed a gid: Jid. Replace result.gid with result.metadata.id when upgrading (GroupMetadata.id, not jid). The same migration applies to CreateCommunityResult.

GroupJoinError

Error codes returned when joining a group via invite fails.

pub enum GroupJoinError {
    AlreadyMember,       // 304 - Already a member of the group
    BadRequest,          // 400 - Invalid request
    Forbidden,           // 403 - Not allowed to join
    NotFound,            // 404 - Group not found
    NotAllowed,          // 405 - Join method not allowed
    Conflict,            // 409 - Conflicting state
    Gone,                // 410 - Group no longer exists
    CommunityFull,       // 412 - Community has reached capacity
    GroupFull,           // 419 - Group has reached capacity
    Locked,              // 423 - Group is locked
    Unknown(u16),        // Other error code
}

Methods:

from_code(code: u16) -> Self - Create from a numeric status code
code(&self) -> u16 - Get the numeric status code

InviteInfoError

Error codes returned when fetching group info from an invite code.

pub enum InviteInfoError {
    BadRequest,            // 400 - Invalid request
    NotAuthorized,         // 401 - Not authorized
    NotFound,              // 404 - Invite code not found
    NotAcceptable,         // 406 - Not acceptable
    Gone,                  // 410 - Invite code expired
    ParentGroupSuspended,  // 416 - Parent community is suspended
    Locked,                // 423 - Group is locked
    GrowthLocked,          // 436 - Group growth is temporarily locked
    Unknown(u16),          // Other error code
}

Methods:

from_code(code: u16) -> Self - Create from a numeric status code
code(&self) -> u16 - Get the numeric status code

Error types

`GroupError`

All group methods return Result<T, GroupError>:

#[derive(Debug, thiserror::Error)]
#[non_exhaustive]
pub enum GroupError {
    #[error("{0}")]
    Iq(#[from] IqError),
    #[error("{0}")]
    Mex(#[from] MexError),
    #[error("invalid group request: {0}")]
    InvalidRequest(String),
    #[error("the group description changed since it was read")]
    DescriptionConflict,
    #[error("{0}")]
    Internal(#[from] anyhow::Error),
}

Variants:

Iq — IQ request failed (timeout, server rejection, etc.)
Mex — MEX protocol error (for methods using the MEX transport)
InvalidRequest — malformed request (expired invite, missing fields, etc.)
DescriptionConflict — set_description’s prev token no longer matches the group’s current description (the server answered 409 conflict); another device changed it first. Kept distinct from a permission refusal so a caller can re-read the description and retry instead of giving up.
Internal — catch-all for other errors

use whatsapp_rust::GroupError;

match client.groups().leave(&group_jid).await {
    Ok(_) => println!("Left group"),
    Err(GroupError::Iq(e)) => eprintln!("Server rejected: {}", e),
    Err(GroupError::InvalidRequest(msg)) => eprintln!("Bad request: {}", msg),
    Err(e) => eprintln!("Error: {}", e),
}

​Access

​Methods

​query_info

​query_info_with_freshness

​get_participating

​get_metadata

​create_group

​set_subject

​set_description

​leave

​add_participants

​remove_participants

​remove_participants_including_linked_groups

​promote_participants

​demote_participants

​get_invite_link

​join_with_invite_code

​join_with_invite_v4

​get_invite_info

​set_locked

​set_announce

​set_ephemeral

​set_membership_approval

​get_membership_requests

​approve_membership_requests

​reject_membership_requests

​set_member_add_mode

​set_no_frequently_forwarded

​set_allow_admin_reports

​set_group_history

​set_member_link_mode

​set_member_share_history_mode

​set_limit_sharing

​cancel_membership_requests

​revoke_request_code

​acknowledge

​update_member_label_with_id

​batch_get_info

​set_profile_picture

​remove_profile_picture

​get_profile_pictures

​Types

​Freshness

​GroupInfo

​GroupSubject

​GroupDescription

​PreviousDescription

​GroupEphemeralSettings

​MemberAddMode

​ParticipantType

​GroupParticipantDetails

​MemberLinkMode

​MemberShareHistoryMode

​MembershipApprovalMode

​GroupAppealStatus

​GroupParticipantOptions

​JoinGroupResult

​MembershipRequest

​ParticipantChangeResponse

​AddressingMode

​BatchGroupResult

​GrowthLockInfo

​PictureType

​GroupProfilePicture

​CreateGroupResult

​GroupJoinError

​InviteInfoError

​Error types

​GroupError

Access

Methods

query_info

`query_info_with_freshness`

get_participating

get_metadata

create_group

set_subject

set_description

leave

add_participants

remove_participants

remove_participants_including_linked_groups

promote_participants

demote_participants

get_invite_link

join_with_invite_code

join_with_invite_v4

get_invite_info

set_locked

set_announce

set_ephemeral

set_membership_approval

get_membership_requests

approve_membership_requests

reject_membership_requests

set_member_add_mode

set_no_frequently_forwarded

set_allow_admin_reports

set_group_history

set_member_link_mode

set_member_share_history_mode

set_limit_sharing

cancel_membership_requests

revoke_request_code

acknowledge

update_member_label_with_id

batch_get_info

set_profile_picture

remove_profile_picture

get_profile_pictures

Types

`Freshness`

GroupInfo

GroupSubject

GroupDescription

PreviousDescription

GroupEphemeralSettings

MemberAddMode

ParticipantType

GroupParticipantDetails

MemberLinkMode

MemberShareHistoryMode

MembershipApprovalMode

GroupAppealStatus

GroupParticipantOptions

JoinGroupResult

MembershipRequest

ParticipantChangeResponse

AddressingMode

BatchGroupResult

GrowthLockInfo

PictureType

GroupProfilePicture

CreateGroupResult

GroupJoinError

InviteInfoError

Error types

`GroupError`