The complete Rust
Telegram Bot library

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{SendAnimationParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;
    let animation = todo!();
    // Optional parameters
    let params = SendAnimationParams::new()
        .business_connection_id(None)
        .message_thread_id(None)
        .direct_messages_topic_id(None)
        .duration(None)
        .width(None)
        // ... +14 more optional fields;


    let result = bot.send_animation(
        chat_id,
        animation,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{SendAudioParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;
    let audio = todo!();
    // Optional parameters
    let params = SendAudioParams::new()
        .business_connection_id(None)
        .message_thread_id(None)
        .direct_messages_topic_id(None)
        .caption(None)
        .parse_mode(None)
        // ... +12 more optional fields;


    let result = bot.send_audio(
        chat_id,
        audio,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{SendChatActionParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;
    let action = "example";
    // Optional parameters
    let params = SendChatActionParams::new()
        .business_connection_id(None)
        .message_thread_id(None);


    let result = bot.send_chat_action(
        chat_id,
        action,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{SendChecklistParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let business_connection_id = "example";
    let chat_id = 123456789i64;
    let checklist = InputChecklist::default();
    // Optional parameters
    let params = SendChecklistParams::new()
        .disable_notification(None)
        .protect_content(None)
        .message_effect_id(None)
        .reply_parameters(None)
        .reply_markup(None);


    let result = bot.send_checklist(
        business_connection_id,
        chat_id,
        checklist,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{SendContactParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;
    let phone_number = "example";
    let first_name = "my_name";
    // Optional parameters
    let params = SendContactParams::new()
        .business_connection_id(None)
        .message_thread_id(None)
        .direct_messages_topic_id(None)
        .last_name(None)
        .vcard(None)
        // ... +7 more optional fields;


    let result = bot.send_contact(
        chat_id,
        phone_number,
        first_name,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{SendDiceParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;
    // Optional parameters
    let params = SendDiceParams::new()
        .business_connection_id(None)
        .message_thread_id(None)
        .direct_messages_topic_id(None)
        .emoji(None)
        .disable_notification(None)
        // ... +6 more optional fields;


    let result = bot.send_dice(
        chat_id,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{SendDocumentParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;
    let document = todo!();
    // Optional parameters
    let params = SendDocumentParams::new()
        .business_connection_id(None)
        .message_thread_id(None)
        .direct_messages_topic_id(None)
        .thumbnail(None)
        .caption(None)
        // ... +10 more optional fields;


    let result = bot.send_document(
        chat_id,
        document,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{SendGameParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;
    let game_short_name = "my_name";
    // Optional parameters
    let params = SendGameParams::new()
        .business_connection_id(None)
        .message_thread_id(None)
        .disable_notification(None)
        .protect_content(None)
        .allow_paid_broadcast(None)
        // ... +3 more optional fields;


    let result = bot.send_game(
        chat_id,
        game_short_name,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{SendGiftParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let gift_id = "example";
    // Optional parameters
    let params = SendGiftParams::new()
        .user_id(None)
        .chat_id(None)
        .pay_for_upgrade(None)
        .text(None)
        .text_parse_mode(None)
        // ... +1 more optional fields;


    let result = bot.send_gift(
        gift_id,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{SendInvoiceParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;
    let title = "example";
    let description = "example";
    let payload = "example";
    let currency = "example";
    let prices = vec![]  // Vec<LabeledPrice>;
    // Optional parameters
    let params = SendInvoiceParams::new()
        .message_thread_id(None)
        .direct_messages_topic_id(None)
        .provider_token(None)
        .max_tip_amount(None)
        .suggested_tip_amounts(None)
        // ... +20 more optional fields;


    let result = bot.send_invoice(
        chat_id,
        title,
        description,
        payload,
        currency,
        prices,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{SendLocationParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;
    let latitude = 0.0;
    let longitude = 0.0;
    // Optional parameters
    let params = SendLocationParams::new()
        .business_connection_id(None)
        .message_thread_id(None)
        .direct_messages_topic_id(None)
        .horizontal_accuracy(None)
        .live_period(None)
        // ... +9 more optional fields;


    let result = bot.send_location(
        chat_id,
        latitude,
        longitude,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{SendMediaGroupParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;
    let media = todo!();
    // Optional parameters
    let params = SendMediaGroupParams::new()
        .business_connection_id(None)
        .message_thread_id(None)
        .direct_messages_topic_id(None)
        .disable_notification(None)
        .protect_content(None)
        // ... +3 more optional fields;


    let result = bot.send_media_group(
        chat_id,
        media,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{SendMessageParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;
    let text = "Hello from tgbotrs! 🦀";
    // Optional parameters
    let params = SendMessageParams::new()
        .business_connection_id(None)
        .message_thread_id(None)
        .direct_messages_topic_id(None)
        .parse_mode(None)
        .entities(None)
        // ... +8 more optional fields;


    let result = bot.send_message(
        chat_id,
        text,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{SendMessageDraftParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;
    let draft_id = 0i64;
    let text = "Hello from tgbotrs! 🦀";
    // Optional parameters
    let params = SendMessageDraftParams::new()
        .message_thread_id(None)
        .parse_mode(None)
        .entities(None);


    let result = bot.send_message_draft(
        chat_id,
        draft_id,
        text,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{SendPaidMediaParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;
    let star_count = 0i64;
    let media = vec![]  // Vec<InputPaidMedia>;
    // Optional parameters
    let params = SendPaidMediaParams::new()
        .business_connection_id(None)
        .message_thread_id(None)
        .direct_messages_topic_id(None)
        .payload(None)
        .caption(None)
        // ... +9 more optional fields;


    let result = bot.send_paid_media(
        chat_id,
        star_count,
        media,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{SendPhotoParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;
    let photo = todo!();
    // Optional parameters
    let params = SendPhotoParams::new()
        .business_connection_id(None)
        .message_thread_id(None)
        .direct_messages_topic_id(None)
        .caption(None)
        .parse_mode(None)
        // ... +10 more optional fields;


    let result = bot.send_photo(
        chat_id,
        photo,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{SendPollParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;
    let question = "example";
    let options = vec![]  // Vec<InputPollOption>;
    // Optional parameters
    let params = SendPollParams::new()
        .business_connection_id(None)
        .message_thread_id(None)
        .question_parse_mode(None)
        .question_entities(None)
        .is_anonymous(None)
        // ... +14 more optional fields;


    let result = bot.send_poll(
        chat_id,
        question,
        options,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{SendStickerParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;
    let sticker = todo!();
    // Optional parameters
    let params = SendStickerParams::new()
        .business_connection_id(None)
        .message_thread_id(None)
        .direct_messages_topic_id(None)
        .emoji(None)
        .disable_notification(None)
        // ... +6 more optional fields;


    let result = bot.send_sticker(
        chat_id,
        sticker,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{SendVenueParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;
    let latitude = 0.0;
    let longitude = 0.0;
    let title = "example";
    let address = "example";
    // Optional parameters
    let params = SendVenueParams::new()
        .business_connection_id(None)
        .message_thread_id(None)
        .direct_messages_topic_id(None)
        .foursquare_id(None)
        .foursquare_type(None)
        // ... +9 more optional fields;


    let result = bot.send_venue(
        chat_id,
        latitude,
        longitude,
        title,
        address,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{SendVideoParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;
    let video = todo!();
    // Optional parameters
    let params = SendVideoParams::new()
        .business_connection_id(None)
        .message_thread_id(None)
        .direct_messages_topic_id(None)
        .duration(None)
        .width(None)
        // ... +17 more optional fields;


    let result = bot.send_video(
        chat_id,
        video,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{SendVideoNoteParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;
    let video_note = todo!();
    // Optional parameters
    let params = SendVideoNoteParams::new()
        .business_connection_id(None)
        .message_thread_id(None)
        .direct_messages_topic_id(None)
        .duration(None)
        .length(None)
        // ... +8 more optional fields;


    let result = bot.send_video_note(
        chat_id,
        video_note,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{SendVoiceParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;
    let voice = todo!();
    // Optional parameters
    let params = SendVoiceParams::new()
        .business_connection_id(None)
        .message_thread_id(None)
        .direct_messages_topic_id(None)
        .caption(None)
        .parse_mode(None)
        // ... +9 more optional fields;


    let result = bot.send_voice(
        chat_id,
        voice,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;


    let result = bot.get_available_gifts().await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{GetBusinessAccountGiftsParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let business_connection_id = "example";
    // Optional parameters
    let params = GetBusinessAccountGiftsParams::new()
        .exclude_unsaved(None)
        .exclude_saved(None)
        .exclude_unlimited(None)
        .exclude_limited_upgradable(None)
        .exclude_limited_non_upgradable(None)
        // ... +5 more optional fields;


    let result = bot.get_business_account_gifts(
        business_connection_id,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let business_connection_id = "example";

    let result = bot.get_business_account_star_balance(
        business_connection_id
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let business_connection_id = "example";

    let result = bot.get_business_connection(
        business_connection_id
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;

    let result = bot.get_chat(
        chat_id
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;

    let result = bot.get_chat_administrators(
        chat_id
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{GetChatGiftsParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;
    // Optional parameters
    let params = GetChatGiftsParams::new()
        .exclude_unsaved(None)
        .exclude_saved(None)
        .exclude_unlimited(None)
        .exclude_limited_upgradable(None)
        .exclude_limited_non_upgradable(None)
        // ... +5 more optional fields;


    let result = bot.get_chat_gifts(
        chat_id,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;
    let user_id = 123456789i64;

    let result = bot.get_chat_member(
        chat_id,
        user_id
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;

    let result = bot.get_chat_member_count(
        chat_id
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{GetChatMenuButtonParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    // Optional parameters
    let params = GetChatMenuButtonParams::new()
        .chat_id(None);


    let result = bot.get_chat_menu_button(
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let custom_emoji_ids = vec![]  // Vec<String>;

    let result = bot.get_custom_emoji_stickers(
        custom_emoji_ids
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let file_id = "example";

    let result = bot.get_file(
        file_id
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;


    let result = bot.get_forum_topic_icon_stickers().await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{GetGameHighScoresParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let user_id = 123456789i64;
    // Optional parameters
    let params = GetGameHighScoresParams::new()
        .chat_id(None)
        .message_id(None)
        .inline_message_id(None);


    let result = bot.get_game_high_scores(
        user_id,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;


    let result = bot.get_me().await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{GetMyCommandsParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    // Optional parameters
    let params = GetMyCommandsParams::new()
        .scope(None)
        .language_code(None);


    let result = bot.get_my_commands(
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{GetMyDefaultAdministratorRightsParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    // Optional parameters
    let params = GetMyDefaultAdministratorRightsParams::new()
        .for_channels(None);


    let result = bot.get_my_default_administrator_rights(
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{GetMyDescriptionParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    // Optional parameters
    let params = GetMyDescriptionParams::new()
        .language_code(None);


    let result = bot.get_my_description(
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{GetMyNameParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    // Optional parameters
    let params = GetMyNameParams::new()
        .language_code(None);


    let result = bot.get_my_name(
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{GetMyShortDescriptionParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    // Optional parameters
    let params = GetMyShortDescriptionParams::new()
        .language_code(None);


    let result = bot.get_my_short_description(
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;


    let result = bot.get_my_star_balance().await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{GetStarTransactionsParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    // Optional parameters
    let params = GetStarTransactionsParams::new()
        .offset(None)
        .limit(None);


    let result = bot.get_star_transactions(
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let name = "my_name";

    let result = bot.get_sticker_set(
        name
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{GetUpdatesParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    // Optional parameters
    let params = GetUpdatesParams::new()
        .offset(None)
        .limit(None)
        .timeout(None)
        .allowed_updates(None);


    let result = bot.get_updates(
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;
    let user_id = 123456789i64;

    let result = bot.get_user_chat_boosts(
        chat_id,
        user_id
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{GetUserGiftsParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let user_id = 123456789i64;
    // Optional parameters
    let params = GetUserGiftsParams::new()
        .exclude_unlimited(None)
        .exclude_limited_upgradable(None)
        .exclude_limited_non_upgradable(None)
        .exclude_from_blockchain(None)
        .exclude_unique(None)
        // ... +3 more optional fields;


    let result = bot.get_user_gifts(
        user_id,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{GetUserProfileAudiosParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let user_id = 123456789i64;
    // Optional parameters
    let params = GetUserProfileAudiosParams::new()
        .offset(None)
        .limit(None);


    let result = bot.get_user_profile_audios(
        user_id,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{GetUserProfilePhotosParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let user_id = 123456789i64;
    // Optional parameters
    let params = GetUserProfilePhotosParams::new()
        .offset(None)
        .limit(None);


    let result = bot.get_user_profile_photos(
        user_id,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;


    let result = bot.get_webhook_info().await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{EditChatInviteLinkParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;
    let invite_link = "example";
    // Optional parameters
    let params = EditChatInviteLinkParams::new()
        .name(None)
        .expire_date(None)
        .member_limit(None)
        .creates_join_request(None);


    let result = bot.edit_chat_invite_link(
        chat_id,
        invite_link,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{EditChatSubscriptionInviteLinkParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;
    let invite_link = "example";
    // Optional parameters
    let params = EditChatSubscriptionInviteLinkParams::new()
        .name(None);


    let result = bot.edit_chat_subscription_invite_link(
        chat_id,
        invite_link,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{EditForumTopicParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;
    let message_thread_id = 0i64;
    // Optional parameters
    let params = EditForumTopicParams::new()
        .name(None)
        .icon_custom_emoji_id(None);


    let result = bot.edit_forum_topic(
        chat_id,
        message_thread_id,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;
    let name = "my_name";

    let result = bot.edit_general_forum_topic(
        chat_id,
        name
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{EditMessageCaptionParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    // Optional parameters
    let params = EditMessageCaptionParams::new()
        .business_connection_id(None)
        .chat_id(None)
        .message_id(None)
        .inline_message_id(None)
        .caption(None)
        // ... +4 more optional fields;


    let result = bot.edit_message_caption(
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{EditMessageChecklistParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let business_connection_id = "example";
    let chat_id = 123456789i64;
    let message_id = 0i64;
    let checklist = InputChecklist::default();
    // Optional parameters
    let params = EditMessageChecklistParams::new()
        .reply_markup(None);


    let result = bot.edit_message_checklist(
        business_connection_id,
        chat_id,
        message_id,
        checklist,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{EditMessageLiveLocationParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let latitude = 0.0;
    let longitude = 0.0;
    // Optional parameters
    let params = EditMessageLiveLocationParams::new()
        .business_connection_id(None)
        .chat_id(None)
        .message_id(None)
        .inline_message_id(None)
        .live_period(None)
        // ... +4 more optional fields;


    let result = bot.edit_message_live_location(
        latitude,
        longitude,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{EditMessageMediaParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let media = todo!();
    // Optional parameters
    let params = EditMessageMediaParams::new()
        .business_connection_id(None)
        .chat_id(None)
        .message_id(None)
        .inline_message_id(None)
        .reply_markup(None);


    let result = bot.edit_message_media(
        media,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{EditMessageReplyMarkupParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    // Optional parameters
    let params = EditMessageReplyMarkupParams::new()
        .business_connection_id(None)
        .chat_id(None)
        .message_id(None)
        .inline_message_id(None)
        .reply_markup(None);


    let result = bot.edit_message_reply_markup(
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{EditMessageTextParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let text = "Hello from tgbotrs! 🦀";
    // Optional parameters
    let params = EditMessageTextParams::new()
        .business_connection_id(None)
        .chat_id(None)
        .message_id(None)
        .inline_message_id(None)
        .parse_mode(None)
        // ... +3 more optional fields;


    let result = bot.edit_message_text(
        text,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{EditStoryParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let business_connection_id = "example";
    let story_id = 0i64;
    let content = InputStoryContent::default();
    // Optional parameters
    let params = EditStoryParams::new()
        .caption(None)
        .parse_mode(None)
        .caption_entities(None)
        .areas(None);


    let result = bot.edit_story(
        business_connection_id,
        story_id,
        content,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let user_id = 123456789i64;
    let telegram_payment_charge_id = "example";
    let is_canceled = true;

    let result = bot.edit_user_star_subscription(
        user_id,
        telegram_payment_charge_id,
        is_canceled
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let business_connection_id = "example";
    let message_ids = vec![]  // Vec<i64>;

    let result = bot.delete_business_messages(
        business_connection_id,
        message_ids
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;

    let result = bot.delete_chat_photo(
        chat_id
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;

    let result = bot.delete_chat_sticker_set(
        chat_id
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;
    let message_thread_id = 0i64;

    let result = bot.delete_forum_topic(
        chat_id,
        message_thread_id
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;
    let message_id = 0i64;

    let result = bot.delete_message(
        chat_id,
        message_id
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;
    let message_ids = vec![]  // Vec<i64>;

    let result = bot.delete_messages(
        chat_id,
        message_ids
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{DeleteMyCommandsParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    // Optional parameters
    let params = DeleteMyCommandsParams::new()
        .scope(None)
        .language_code(None);


    let result = bot.delete_my_commands(
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let sticker = "example";

    let result = bot.delete_sticker_from_set(
        sticker
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let name = "my_name";

    let result = bot.delete_sticker_set(
        name
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let business_connection_id = "example";
    let story_id = 0i64;

    let result = bot.delete_story(
        business_connection_id,
        story_id
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{DeleteWebhookParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    // Optional parameters
    let params = DeleteWebhookParams::new()
        .drop_pending_updates(None);


    let result = bot.delete_webhook(
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{CopyMessageParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;
    let from_chat_id = 123456789i64;
    let message_id = 0i64;
    // Optional parameters
    let params = CopyMessageParams::new()
        .message_thread_id(None)
        .direct_messages_topic_id(None)
        .video_start_timestamp(None)
        .caption(None)
        .parse_mode(None)
        // ... +9 more optional fields;


    let result = bot.copy_message(
        chat_id,
        from_chat_id,
        message_id,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{CopyMessagesParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;
    let from_chat_id = 123456789i64;
    let message_ids = vec![]  // Vec<i64>;
    // Optional parameters
    let params = CopyMessagesParams::new()
        .message_thread_id(None)
        .direct_messages_topic_id(None)
        .disable_notification(None)
        .protect_content(None)
        .remove_caption(None);


    let result = bot.copy_messages(
        chat_id,
        from_chat_id,
        message_ids,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{ForwardMessageParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;
    let from_chat_id = 123456789i64;
    let message_id = 0i64;
    // Optional parameters
    let params = ForwardMessageParams::new()
        .message_thread_id(None)
        .direct_messages_topic_id(None)
        .video_start_timestamp(None)
        .disable_notification(None)
        .protect_content(None)
        // ... +2 more optional fields;


    let result = bot.forward_message(
        chat_id,
        from_chat_id,
        message_id,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{ForwardMessagesParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;
    let from_chat_id = 123456789i64;
    let message_ids = vec![]  // Vec<i64>;
    // Optional parameters
    let params = ForwardMessagesParams::new()
        .message_thread_id(None)
        .direct_messages_topic_id(None)
        .disable_notification(None)
        .protect_content(None);


    let result = bot.forward_messages(
        chat_id,
        from_chat_id,
        message_ids,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{AnswerCallbackQueryParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let callback_query_id = "example";
    // Optional parameters
    let params = AnswerCallbackQueryParams::new()
        .text(None)
        .show_alert(None)
        .url(None)
        .cache_time(None);


    let result = bot.answer_callback_query(
        callback_query_id,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{AnswerInlineQueryParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let inline_query_id = "example";
    let results = vec![]  // Vec<InlineQueryResult>;
    // Optional parameters
    let params = AnswerInlineQueryParams::new()
        .cache_time(None)
        .is_personal(None)
        .next_offset(None)
        .button(None);


    let result = bot.answer_inline_query(
        inline_query_id,
        results,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{AnswerPreCheckoutQueryParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let pre_checkout_query_id = "example";
    let ok = true;
    // Optional parameters
    let params = AnswerPreCheckoutQueryParams::new()
        .error_message(None);


    let result = bot.answer_pre_checkout_query(
        pre_checkout_query_id,
        ok,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{AnswerShippingQueryParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let shipping_query_id = "example";
    let ok = true;
    // Optional parameters
    let params = AnswerShippingQueryParams::new()
        .shipping_options(None)
        .error_message(None);


    let result = bot.answer_shipping_query(
        shipping_query_id,
        ok,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let web_app_query_id = "example";
    let result = InlineQueryResult::default();

    let result = bot.answer_web_app_query(
        web_app_query_id,
        result
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{BanChatMemberParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;
    let user_id = 123456789i64;
    // Optional parameters
    let params = BanChatMemberParams::new()
        .until_date(None)
        .revoke_messages(None);


    let result = bot.ban_chat_member(
        chat_id,
        user_id,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;
    let sender_chat_id = 123456789i64;

    let result = bot.ban_chat_sender_chat(
        chat_id,
        sender_chat_id
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{PromoteChatMemberParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;
    let user_id = 123456789i64;
    // Optional parameters
    let params = PromoteChatMemberParams::new()
        .is_anonymous(None)
        .can_manage_chat(None)
        .can_delete_messages(None)
        .can_manage_video_chats(None)
        .can_restrict_members(None)
        // ... +11 more optional fields;


    let result = bot.promote_chat_member(
        chat_id,
        user_id,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{RestrictChatMemberParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;
    let user_id = 123456789i64;
    let permissions = ChatPermissions::default();
    // Optional parameters
    let params = RestrictChatMemberParams::new()
        .use_independent_chat_permissions(None)
        .until_date(None);


    let result = bot.restrict_chat_member(
        chat_id,
        user_id,
        permissions,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{UnbanChatMemberParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;
    let user_id = 123456789i64;
    // Optional parameters
    let params = UnbanChatMemberParams::new()
        .only_if_banned(None);


    let result = bot.unban_chat_member(
        chat_id,
        user_id,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;
    let sender_chat_id = 123456789i64;

    let result = bot.unban_chat_sender_chat(
        chat_id,
        sender_chat_id
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;
    let user_id = 123456789i64;

    let result = bot.approve_chat_join_request(
        chat_id,
        user_id
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{ApproveSuggestedPostParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;
    let message_id = 0i64;
    // Optional parameters
    let params = ApproveSuggestedPostParams::new()
        .send_date(None);


    let result = bot.approve_suggested_post(
        chat_id,
        message_id,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{CreateChatInviteLinkParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;
    // Optional parameters
    let params = CreateChatInviteLinkParams::new()
        .name(None)
        .expire_date(None)
        .member_limit(None)
        .creates_join_request(None);


    let result = bot.create_chat_invite_link(
        chat_id,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{CreateChatSubscriptionInviteLinkParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;
    let subscription_period = 0i64;
    let subscription_price = 0i64;
    // Optional parameters
    let params = CreateChatSubscriptionInviteLinkParams::new()
        .name(None);


    let result = bot.create_chat_subscription_invite_link(
        chat_id,
        subscription_period,
        subscription_price,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{CreateForumTopicParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;
    let name = "my_name";
    // Optional parameters
    let params = CreateForumTopicParams::new()
        .icon_color(None)
        .icon_custom_emoji_id(None);


    let result = bot.create_forum_topic(
        chat_id,
        name,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{CreateInvoiceLinkParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let title = "example";
    let description = "example";
    let payload = "example";
    let currency = "example";
    let prices = vec![]  // Vec<LabeledPrice>;
    // Optional parameters
    let params = CreateInvoiceLinkParams::new()
        .business_connection_id(None)
        .provider_token(None)
        .subscription_period(None)
        .max_tip_amount(None)
        .suggested_tip_amounts(None)
        // ... +12 more optional fields;


    let result = bot.create_invoice_link(
        title,
        description,
        payload,
        currency,
        prices,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{CreateNewStickerSetParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let user_id = 123456789i64;
    let name = "my_name";
    let title = "example";
    let stickers = vec![]  // Vec<InputSticker>;
    // Optional parameters
    let params = CreateNewStickerSetParams::new()
        .sticker_type(None)
        .needs_repainting(None);


    let result = bot.create_new_sticker_set(
        user_id,
        name,
        title,
        stickers,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;
    let user_id = 123456789i64;

    let result = bot.decline_chat_join_request(
        chat_id,
        user_id
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{DeclineSuggestedPostParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;
    let message_id = 0i64;
    // Optional parameters
    let params = DeclineSuggestedPostParams::new()
        .comment(None);


    let result = bot.decline_suggested_post(
        chat_id,
        message_id,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;
    let invite_link = "example";

    let result = bot.revoke_chat_invite_link(
        chat_id,
        invite_link
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{PinChatMessageParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;
    let message_id = 0i64;
    // Optional parameters
    let params = PinChatMessageParams::new()
        .business_connection_id(None)
        .disable_notification(None);


    let result = bot.pin_chat_message(
        chat_id,
        message_id,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;

    let result = bot.unpin_all_chat_messages(
        chat_id
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;
    let message_thread_id = 0i64;

    let result = bot.unpin_all_forum_topic_messages(
        chat_id,
        message_thread_id
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;

    let result = bot.unpin_all_general_forum_topic_messages(
        chat_id
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{UnpinChatMessageParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;
    // Optional parameters
    let params = UnpinChatMessageParams::new()
        .business_connection_id(None)
        .message_id(None);


    let result = bot.unpin_chat_message(
        chat_id,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{SetBusinessAccountBioParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let business_connection_id = "example";
    // Optional parameters
    let params = SetBusinessAccountBioParams::new()
        .bio(None);


    let result = bot.set_business_account_bio(
        business_connection_id,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let business_connection_id = "example";
    let show_gift_button = true;
    let accepted_gift_types = AcceptedGiftTypes::default();

    let result = bot.set_business_account_gift_settings(
        business_connection_id,
        show_gift_button,
        accepted_gift_types
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{SetBusinessAccountNameParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let business_connection_id = "example";
    let first_name = "my_name";
    // Optional parameters
    let params = SetBusinessAccountNameParams::new()
        .last_name(None);


    let result = bot.set_business_account_name(
        business_connection_id,
        first_name,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{SetBusinessAccountProfilePhotoParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let business_connection_id = "example";
    let photo = InputProfilePhoto::default();
    // Optional parameters
    let params = SetBusinessAccountProfilePhotoParams::new()
        .is_public(None);


    let result = bot.set_business_account_profile_photo(
        business_connection_id,
        photo,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{SetBusinessAccountUsernameParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let business_connection_id = "example";
    // Optional parameters
    let params = SetBusinessAccountUsernameParams::new()
        .username(None);


    let result = bot.set_business_account_username(
        business_connection_id,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;
    let user_id = 123456789i64;
    let custom_title = "example";

    let result = bot.set_chat_administrator_custom_title(
        chat_id,
        user_id,
        custom_title
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{SetChatDescriptionParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;
    // Optional parameters
    let params = SetChatDescriptionParams::new()
        .description(None);


    let result = bot.set_chat_description(
        chat_id,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{SetChatMenuButtonParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    // Optional parameters
    let params = SetChatMenuButtonParams::new()
        .chat_id(None)
        .menu_button(None);


    let result = bot.set_chat_menu_button(
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{SetChatPermissionsParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;
    let permissions = ChatPermissions::default();
    // Optional parameters
    let params = SetChatPermissionsParams::new()
        .use_independent_chat_permissions(None);


    let result = bot.set_chat_permissions(
        chat_id,
        permissions,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;
    let photo = InputFile::default();

    let result = bot.set_chat_photo(
        chat_id,
        photo
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;
    let sticker_set_name = "my_name";

    let result = bot.set_chat_sticker_set(
        chat_id,
        sticker_set_name
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;
    let title = "example";

    let result = bot.set_chat_title(
        chat_id,
        title
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{SetCustomEmojiStickerSetThumbnailParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let name = "my_name";
    // Optional parameters
    let params = SetCustomEmojiStickerSetThumbnailParams::new()
        .custom_emoji_id(None);


    let result = bot.set_custom_emoji_sticker_set_thumbnail(
        name,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{SetGameScoreParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let user_id = 123456789i64;
    let score = 0i64;
    // Optional parameters
    let params = SetGameScoreParams::new()
        .force(None)
        .disable_edit_message(None)
        .chat_id(None)
        .message_id(None)
        .inline_message_id(None);


    let result = bot.set_game_score(
        user_id,
        score,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{SetMessageReactionParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;
    let message_id = 0i64;
    // Optional parameters
    let params = SetMessageReactionParams::new()
        .reaction(None)
        .is_big(None);


    let result = bot.set_message_reaction(
        chat_id,
        message_id,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{SetMyCommandsParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let commands = vec![]  // Vec<BotCommand>;
    // Optional parameters
    let params = SetMyCommandsParams::new()
        .scope(None)
        .language_code(None);


    let result = bot.set_my_commands(
        commands,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{SetMyDefaultAdministratorRightsParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    // Optional parameters
    let params = SetMyDefaultAdministratorRightsParams::new()
        .rights(None)
        .for_channels(None);


    let result = bot.set_my_default_administrator_rights(
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{SetMyDescriptionParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    // Optional parameters
    let params = SetMyDescriptionParams::new()
        .description(None)
        .language_code(None);


    let result = bot.set_my_description(
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{SetMyNameParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    // Optional parameters
    let params = SetMyNameParams::new()
        .name(None)
        .language_code(None);


    let result = bot.set_my_name(
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let photo = InputProfilePhoto::default();

    let result = bot.set_my_profile_photo(
        photo
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{SetMyShortDescriptionParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    // Optional parameters
    let params = SetMyShortDescriptionParams::new()
        .short_description(None)
        .language_code(None);


    let result = bot.set_my_short_description(
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let user_id = 123456789i64;
    let errors = vec![]  // Vec<PassportElementError>;

    let result = bot.set_passport_data_errors(
        user_id,
        errors
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let sticker = "example";
    let emoji_list = vec![]  // Vec<String>;

    let result = bot.set_sticker_emoji_list(
        sticker,
        emoji_list
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{SetStickerKeywordsParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let sticker = "example";
    // Optional parameters
    let params = SetStickerKeywordsParams::new()
        .keywords(None);


    let result = bot.set_sticker_keywords(
        sticker,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{SetStickerMaskPositionParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let sticker = "example";
    // Optional parameters
    let params = SetStickerMaskPositionParams::new()
        .mask_position(None);


    let result = bot.set_sticker_mask_position(
        sticker,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let sticker = "example";
    let position = 0i64;

    let result = bot.set_sticker_position_in_set(
        sticker,
        position
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{SetStickerSetThumbnailParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let name = "my_name";
    let user_id = 123456789i64;
    let format = "example";
    // Optional parameters
    let params = SetStickerSetThumbnailParams::new()
        .thumbnail(None);


    let result = bot.set_sticker_set_thumbnail(
        name,
        user_id,
        format,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let name = "my_name";
    let title = "example";

    let result = bot.set_sticker_set_title(
        name,
        title
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{SetUserEmojiStatusParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let user_id = 123456789i64;
    // Optional parameters
    let params = SetUserEmojiStatusParams::new()
        .emoji_status_custom_emoji_id(None)
        .emoji_status_expiration_date(None);


    let result = bot.set_user_emoji_status(
        user_id,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{SetWebhookParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let url = "https://example.com";
    // Optional parameters
    let params = SetWebhookParams::new()
        .certificate(None)
        .ip_address(None)
        .max_connections(None)
        .allowed_updates(None)
        .drop_pending_updates(None)
        // ... +1 more optional fields;


    let result = bot.set_webhook(
        url,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;


    let result = bot.close().await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let user_id = 123456789i64;
    let name = "my_name";
    let sticker = InputSticker::default();

    let result = bot.add_sticker_to_set(
        user_id,
        name,
        sticker
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let user_id = 123456789i64;
    let name = "my_name";
    let old_sticker = "example";
    let sticker = InputSticker::default();

    let result = bot.replace_sticker_in_set(
        user_id,
        name,
        old_sticker,
        sticker
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let user_id = 123456789i64;
    let sticker = InputFile::default();
    let sticker_format = "example";

    let result = bot.upload_sticker_file(
        user_id,
        sticker,
        sticker_format
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;
    let message_thread_id = 0i64;

    let result = bot.close_forum_topic(
        chat_id,
        message_thread_id
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;

    let result = bot.close_general_forum_topic(
        chat_id
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;

    let result = bot.hide_general_forum_topic(
        chat_id
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;
    let message_thread_id = 0i64;

    let result = bot.reopen_forum_topic(
        chat_id,
        message_thread_id
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;

    let result = bot.reopen_general_forum_topic(
        chat_id
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;

    let result = bot.unhide_general_forum_topic(
        chat_id
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let business_connection_id = "example";
    let owned_gift_id = "example";

    let result = bot.convert_gift_to_stars(
        business_connection_id,
        owned_gift_id
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{GiftPremiumSubscriptionParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let user_id = 123456789i64;
    let month_count = 0i64;
    let star_count = 0i64;
    // Optional parameters
    let params = GiftPremiumSubscriptionParams::new()
        .text(None)
        .text_parse_mode(None)
        .text_entities(None);


    let result = bot.gift_premium_subscription(
        user_id,
        month_count,
        star_count,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let user_id = 123456789i64;
    let telegram_payment_charge_id = "example";

    let result = bot.refund_star_payment(
        user_id,
        telegram_payment_charge_id
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let business_connection_id = "example";
    let star_count = 0i64;

    let result = bot.transfer_business_account_stars(
        business_connection_id,
        star_count
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{TransferGiftParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let business_connection_id = "example";
    let owned_gift_id = "example";
    let new_owner_chat_id = 123456789i64;
    // Optional parameters
    let params = TransferGiftParams::new()
        .star_count(None);


    let result = bot.transfer_gift(
        business_connection_id,
        owned_gift_id,
        new_owner_chat_id,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{UpgradeGiftParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let business_connection_id = "example";
    let owned_gift_id = "example";
    // Optional parameters
    let params = UpgradeGiftParams::new()
        .keep_original_details(None)
        .star_count(None);


    let result = bot.upgrade_gift(
        business_connection_id,
        owned_gift_id,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{PostStoryParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let business_connection_id = "example";
    let content = InputStoryContent::default();
    let active_period = 0i64;
    // Optional parameters
    let params = PostStoryParams::new()
        .caption(None)
        .parse_mode(None)
        .caption_entities(None)
        .areas(None)
        .post_to_chat_page(None)
        // ... +1 more optional fields;


    let result = bot.post_story(
        business_connection_id,
        content,
        active_period,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{RepostStoryParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let business_connection_id = "example";
    let from_chat_id = 123456789i64;
    let from_story_id = 0i64;
    let active_period = 0i64;
    // Optional parameters
    let params = RepostStoryParams::new()
        .post_to_chat_page(None)
        .protect_content(None);


    let result = bot.repost_story(
        business_connection_id,
        from_chat_id,
        from_story_id,
        active_period,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let business_connection_id = "example";
    let chat_id = 123456789i64;
    let message_id = 0i64;

    let result = bot.read_business_message(
        business_connection_id,
        chat_id,
        message_id
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{RemoveBusinessAccountProfilePhotoParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let business_connection_id = "example";
    // Optional parameters
    let params = RemoveBusinessAccountProfilePhotoParams::new()
        .is_public(None);


    let result = bot.remove_business_account_profile_photo(
        business_connection_id,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;

    let result = bot.export_chat_invite_link(
        chat_id
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;

    let result = bot.leave_chat(
        chat_id
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;


    let result = bot.log_out().await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;

    let result = bot.remove_chat_verification(
        chat_id
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;


    let result = bot.remove_my_profile_photo().await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let user_id = 123456789i64;

    let result = bot.remove_user_verification(
        user_id
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{SavePreparedInlineMessageParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let user_id = 123456789i64;
    let result = InlineQueryResult::default();
    // Optional parameters
    let params = SavePreparedInlineMessageParams::new()
        .allow_user_chats(None)
        .allow_bot_chats(None)
        .allow_group_chats(None)
        .allow_channel_chats(None);


    let result = bot.save_prepared_inline_message(
        user_id,
        result,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{StopMessageLiveLocationParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    // Optional parameters
    let params = StopMessageLiveLocationParams::new()
        .business_connection_id(None)
        .chat_id(None)
        .message_id(None)
        .inline_message_id(None)
        .reply_markup(None);


    let result = bot.stop_message_live_location(
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{StopPollParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;
    let message_id = 0i64;
    // Optional parameters
    let params = StopPollParams::new()
        .business_connection_id(None)
        .reply_markup(None);


    let result = bot.stop_poll(
        chat_id,
        message_id,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{VerifyChatParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let chat_id = 123456789i64;
    // Optional parameters
    let params = VerifyChatParams::new()
        .custom_description(None);


    let result = bot.verify_chat(
        chat_id,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}

use tgbotrs::{Bot, BotError};
use tgbotrs::gen_methods::{VerifyUserParams};

#[tokio::main]
async fn main() -> Result<(), BotError> {
    let bot = Bot::new("YOUR_BOT_TOKEN").await?;

    let user_id = 123456789i64;
    // Optional parameters
    let params = VerifyUserParams::new()
        .custom_description(None);


    let result = bot.verify_user(
        user_id,
        Some(params)
    ).await?;
    println!("Result: {result:?}");
    Ok(())
}