download

let bytes = client.download(&image_message, whatsapp_rust::download::DownloadLimits::default()).await?;
let bytes = client.download(&persisted_params, whatsapp_rust::download::DownloadLimits::default()).await?;

use std::io::Cursor;
let writer = client.download_to_writer(&persisted_params, Cursor::new(Vec::new()), whatsapp_rust::download::DownloadLimits::default()).await?;

use whatsapp_rust::wacore::download::MusicArtwork;
let artwork = MusicArtwork::for_chat(&embedded_music, &chat_jid);
let bytes = client.download(&artwork, whatsapp_rust::download::DownloadLimits::default()).await?;

pub fn encrypted(
    direct_path: impl Into<String>,
    media_key: &[u8],
    file_sha256: &[u8],
    file_enc_sha256: &[u8],
    file_length: u64,
    media_type: MediaType,
) -> Result<Self, DownloadPreparationError>

pub fn plaintext(
    direct_path: impl Into<String>,
    file_sha256: &[u8],
    file_length: u64,
    media_type: MediaType,
) -> Result<Self, DownloadPreparationError>

use whatsapp_rust::download::{DownloadParams, DownloadPreparationError, Downloadable, MediaType};

fn stored_image(
    path: &str,
    key: &[u8],
    plaintext_hash: &[u8],
    encrypted_hash: &[u8],
    length: u64,
) -> Result<DownloadParams, DownloadPreparationError> {
    let params = DownloadParams::encrypted(
        path, key, plaintext_hash, encrypted_hash, length, MediaType::Image,
    )?;
    assert_eq!(params.file_length(), Some(length));
    Ok(params)
}

fn stored_channel_image(
    path: &str,
    hash: &[u8],
    length: u64,
) -> Result<DownloadParams, DownloadPreparationError> {
    DownloadParams::plaintext(path, hash, length, MediaType::Image)
}

pub struct MediaDownloader { /* private fields */ }

impl MediaDownloader {
    pub fn new(
        http_client: Arc<dyn HttpClient>,
        runtime: Arc<dyn Runtime>,
        route: MediaRoute,
    ) -> Self;

    pub fn with_default_hosts(
        http_client: Arc<dyn HttpClient>,
        runtime: Arc<dyn Runtime>,
    ) -> Self;

    pub fn route(&self) -> &MediaRoute;

    pub async fn download(
        &self,
        downloadable: &dyn Downloadable,
        limits: DownloadLimits,
    ) -> Result<Vec<u8>, MediaDownloadError>;

    pub async fn download_to_writer<W: DownloadWriter + MaybeSend + 'static>(
        &self,
        downloadable: &dyn Downloadable,
        writer: W,
        limits: DownloadLimits,
    ) -> Result<W, MediaDownloadError>;
}

use std::sync::Arc;
use whatsapp_rust::wacore::download::MediaType;
use whatsapp_rust::download::{DownloadParams, MediaDownloader};

// Needs only an HttpClient + Runtime — no paired Client required.
let downloader = MediaDownloader::with_default_hosts(http_client.clone(), runtime.clone());

// `params` came from CDN fields you saved to your own store earlier, while
// the client was still connected. (`PersistenceManager` covers device/session
// state only — it doesn't store message metadata like this for you.)
let params = DownloadParams::encrypted(
    "/v/t62.7118-24/12345_67890",
    &media_key,
    &file_sha256,
    &file_enc_sha256,
    file_length,
    MediaType::Image,
)?;

let bytes = downloader.download(&params, whatsapp_rust::download::DownloadLimits::default()).await?;

#[non_exhaustive]
pub enum MediaDownloadError {
    ResourcePolicy(DownloadPolicyError),
    ReferenceRejected(anyhow::Error),
    HostsUnreachable(anyhow::Error),
    WriterIo(anyhow::Error),
    NoHosts,
    Other(anyhow::Error),
    WriterCleanup { failure: Box<MediaDownloadError>, cleanup: std::io::Error },
}

use whatsapp_rust::download::{MediaHost, MediaRoute};

fn download_route() -> MediaRoute {
    MediaRoute::new(vec![MediaHost::new("mmg.whatsapp.net")])
}

pub async fn fetch_sticker_pack(
    &self,
    pack_id: &str,
    locale: &str,
) -> Result<wacore::sticker_pack::StickerPack>

use whatsapp_rust::Client;

let pack = client.fetch_sticker_pack("3F9Z2…", "en").await?;
println!("Pack {:?} by {:?}", pack.name, pack.publisher);
for (index, sticker) in pack.stickers.iter().enumerate() {
    let bytes = client.download(sticker, whatsapp_rust::download::DownloadLimits::default()).await?;
    std::fs::write(format!("sticker-{index}.webp"), bytes)?;
}

pub struct StickerPack {    pub sticker_pack_id: Option<String>,
    pub name: Option<String>,
    pub publisher: Option<String>,
    pub description: Option<String>,
    pub file_size: Option<String>,
    pub image_data_hash: Option<String>,
    pub stickers: Vec<StickerPackItem>,
    pub animated: i32,
    pub lottie: i32,
    pub preview_image_ids: Vec<String>,
    pub tray_image_id: Option<String>,
    pub tray_image_preview: Option<String>,
}

pub struct StickerPackItem {    pub media_key: Option<Vec<u8>>,
    pub file_hash: Option<Vec<u8>>,
    pub enc_file_hash: Option<Vec<u8>>,
    pub direct_path: Option<String>,
    pub url: Option<String>,
    pub file_size: Option<u64>,
    pub mimetype: Option<String>,
    pub width: Option<u32>,
    pub height: Option<u32>,
    pub emojis: Vec<String>,
    pub accessibility_text: Option<String>,
}

impl Downloadable for StickerPackItem { /* … */ }

pub trait Downloadable: MaybeSendSync {
    fn direct_path(&self) -> Option<&str>;
    fn media_key(&self) -> Option<&[u8]>;
    fn file_enc_sha256(&self) -> Option<&[u8]>;
    fn file_sha256(&self) -> Option<&[u8]>;
    fn file_length(&self) -> Option<u64>;
    fn app_info(&self) -> MediaType;
    fn static_url(&self) -> Option<&str> { None }
    fn is_encrypted(&self) -> bool { self.media_key().is_some() }
}

#[non_exhaustive]
pub enum MediaType {
    Image,
    Video,
    Audio,
    Document,
    History,
    AppState,
    Sticker,
    StickerPack,
    StickerPackThumbnail,
    LinkThumbnail,
    ProductCatalogImage,
    GroupHistory,
    MusicArtwork,
    NewsletterMusicArtwork,
}

if downloadable.is_encrypted() {
    println!("E2EE media - will decrypt");
} else {
    println!("Plaintext media - no decryption needed");
}

use whatsapp_rust::download::DownloadUtils;