Rename tgapi request structs

Add MaybeInaccessibleMessage tests and godoc
Update wiki and Bot API docs for the new naming

AGENTS.md

@@ -32,7 +32,9 @@ Review the codebase with focus on:
 - Treat the wiki as the primary place for large design ideas, architectural drafts, and framework backlog notes.
 - If the agent identifies a substantial new concept or design direction, such as scenes, callback agents, a webhook model, or another framework-level abstraction, the agent must ask the user whether it should also formalize that idea as a draft wiki page.
 - When the user agrees, prefer paired wiki pages such as `Page.md` and `Page-RU.md`, and clearly mark draft design pages with `DRAFT` when the API is not implemented or not yet stable.
-- Keep `TODO.md`, the wiki backlog pages, and `CHANGELOG.md` aligned when framework-level items move between planned and completed states.
+- Keep `TODO.md`, the wiki backlog pages, and `CHANGELOG.md` aligned when framework-level items move between planned and completed states in the main repository.
+- Wiki-only edits must never be added to `CHANGELOG.md`.
+- `AGENTS.md`-only edits must never be added to `CHANGELOG.md`.
 
 ## Go review expectations
 Check for:
@@ -90,7 +92,8 @@ Prefer the repository’s documented commands. If multiple choices exist, use th
 
 ## Versioning and changelog
 - After every code or documentation change in the main repository, update `CHANGELOG.md`.
-- Changes made only inside the `.wiki/` repository do not require a `CHANGELOG.md` update.
+- Changes made only inside the `.wiki/` repository must not be added to `CHANGELOG.md`.
+- Changes made only in `AGENTS.md` must not be added to `CHANGELOG.md`.
 - Add changes only to the section for the next version after the latest published git tag.
 - The agent must check the latest published tag, `CHANGELOG.md`, and `utils/version.go` before editing the changelog.
 - The agent must verify that the target changelog version matches the version declared in `utils/version.go`.

CHANGELOG.md

@@ -1,5 +1,70 @@
 # Changelog
 
+## v1.0.0-rc.14
+
+### Bot API 9.6
+
+#### Managed Bots
+- Added the field can_manage_bots to the class User.
+- Added the class KeyboardButtonRequestManagedBot and the field request_managed_bot to the class KeyboardButton.
+- Added the class ManagedBotCreated and the field managed_bot_created to the class Message.
+- Added updates about the creation of managed bots and the change of their token, represented by the class ManagedBotUpdated and the field managed_bot in the class Update.
+- Added the methods getManagedBotToken and replaceManagedBotToken.
+- Added the class PreparedKeyboardButton and the method savePreparedKeyboardButton, allowing bots to request users, chats and managed bots from Mini Apps.
+- Added the method requestChat to the class WebApp.
+- Added support for https://t.me/newbot/{manager_bot_username}/{suggested_bot_username}[?name={suggested_bot_name}] links, allowing bots to request the creation of a managed bot via a link.
+
+### Polls
+- Added support for quizzes with multiple correct answers.
+- Replaced the field correct_option_id with the field correct_option_ids in the class Poll.
+- Replaced the parameter correct_option_id with the parameter correct_option_ids in the method sendPoll.
+- Allowed to pass allows_multiple_answers for quizzes in the method sendPoll.
+- Increased the maximum time for automatic poll closure to 2628000 seconds.
+- Added the field allows_revoting to the class Poll.
+- Added the parameter allows_revoting to the method sendPoll.
+- Added the parameter shuffle_options to the method sendPoll.
+- Added the parameter allow_adding_options to the method sendPoll.
+- Added the parameter hide_results_until_closes to the method sendPoll.
+- Added the fields description and description_entities to the class Poll.
+- Added the parameters description, description_parse_mode, and description_entities to the method sendPoll.
+- Added the field persistent_id to the class PollOption, representing a persistent identifier for the option.
+- Added the field option_persistent_ids to the class PollAnswer.
+- Added the fields added_by_user and added_by_chat to the class PollOption, denoting the user and the chat which added the option.
+- Added the field addition_date to the class PollOption, describing the date when the option was added.
+- Added the class PollOptionAdded and the field poll_option_added to the class Message.
+- Added the class PollOptionDeleted and the field poll_option_deleted to the class Message.
+- Added the field poll_option_id to the class ReplyParameters, allowing bots to reply to a specific poll option.
+- Added the field reply_to_poll_option_id to the class Message.
+- Allowed “date_time” entities in checklist title, checklist task text, TextQuote, ReplyParameters quote, sendGift, and giftPremiumSubscription.
+
+**More info**: https://core.telegram.org/bots/api#april-3-2026
+
+### Breaking Changes
+- Exported `tgapi` request parameter structs were renamed from the `*P` suffix to their method names. Update code such as `tgapi.SendMessageP{...}` to `tgapi.SendMessage{...}`.
+
+### Changed
+- *Support for Bot API 9.6*
+- Added missing godoc for recently introduced Telegram Bot API managed-bot, prepared-button, chat-owner, and video-quality exported declarations.
+- Renamed exported `tgapi` request parameter structs from the `*P` suffix to their method names, for example `SendMessageP` -> `SendMessage` and `SetWebhookP` -> `SetWebhook`.
+- Added missing godoc for the exported observer `Event` marker interface.
+- Webhook execution now shares the bot's queued update-dispatch path with polling, including worker-pool delivery, runner startup, single-use run semantics, and default fallback to bot-level update type filters when webhook-specific filters are not set.
+- Webhook godoc and the English and Russian READMEs now describe the bot-level webhook runtime, its single-use lifecycle, and the main `RunWebHookWithContext(...)` entry points more explicitly.
+- `Bot.Close()` once again releases only local resources and no longer deletes remote webhook registrations implicitly; explicit remote webhook teardown remains opt-in through `CloseWebHook()`.
+- Polling and webhook docs now explicitly state that a deployment must delete its webhook before switching from webhook delivery to long polling.
+- Webhook startup now validates path shape and TLS file count before remote webhook setup, and the shared webhook mux now serves both HTTP and TLS runtime paths consistently.
+- Webhook-related `tgapi` request params now use `int8` for `max_connections`, matching Telegram's `1..100` range and the higher-level webhook options API.
+- Webhook startup now also requires a non-empty `SecretToken` when the optional `/status` endpoint is enabled, preventing anonymous exposure of webhook operational metadata.
+- Webhook debug logging now records update metadata instead of dumping raw request bodies.
+- Package docs, README guidance, and core wiki pages now align with the current public API and runtime model, including `NoData`, `SetAppData(...)`, `SetL10n(...)`, `AddAppDataLoggerWriter(...)`, shared runner startup semantics, and the webhook runtime entry points.
+
+### Tests
+- Added regression coverage for webhook queue delivery, webhook runtime single-use behavior, runner startup in webhook mode, and default webhook `allowed_updates` inheritance from bot-level update type configuration.
+- Added regression coverage proving `Bot.Close()` does not make remote webhook delete requests.
+- Added webhook regression coverage for path validation, TLS file-count validation, oversized-body rejection, status-endpoint secret checks, and invalid TLS startup arguments.
+- Added webhook regression coverage proving `/status` cannot be enabled without a non-empty `SecretToken`.
+- Added regression coverage for Bot API 9.6 poll decoding, `managed_bot` update decoding, and structured `setChatMenuButton(...)` request serialization.
+- Added regression coverage for `MaybeInaccessibleMessage` accessible and inaccessible JSON decoding.
+
 ## v1.0.0-rc.13
 
 ### Added

README.md

@@ -23,6 +23,7 @@ A lightweight, easy-to-use, and performant Telegram Bot API wrapper for Go. It s
 *   **Built-in Rate Limiting:** Protect your bot from hitting Telegram API limits (supports `retry_after` handling).
 *   **Context-Aware:** Pass custom application data or state contexts to your handlers.
 *   **Configurable API:** Mix `Set...` and `Add...` helpers to configure bots clearly (for example, `bot.SetErrorTemplate(...).AddPlugins(...)`).
+*   **Polling and Webhook Runtime:** Run bots through long polling with `Run()` / `RunWithContext(...)` or through a bot-owned webhook server with `RunWebHookWithContext(...)`.
 
 ---
 
@@ -116,7 +117,26 @@ func main() {
 6. `SetErrorTemplate`: Sets a template for error messages. The %s placeholder is replaced by the actual error.
 7. `AutoGenerateCommands`: Registers plugin-defined commands with Telegram across the supported scopes.
 8. `Run()`: Starts the bot's update polling loop and returns an error if startup or polling fails.
-9. A `Bot` instance is single-use. After `Run()` or `RunWithContext()` returns, create a new bot instance for the next session.
+9. `RunWebHookWithContext(...)`: Starts the bot-owned webhook runtime when Telegram should deliver updates over HTTP instead of long polling.
+10. A `Bot` instance is single-use. After `Run()`, `RunWithContext()`, or `RunWebHookWithContext()` returns, create a new bot instance for the next session.
+
+## Webhook Runtime
+
+Laniakea also supports a bot-owned webhook runtime through `RunWebHookWithContext(...)` and `RunWebHook(...)`.
+
+Use it when:
+- Telegram should push updates to your HTTP endpoint instead of your bot polling for them.
+- You want webhook-delivered updates to reuse the same internal queue, worker pool, runners, and single-use lifecycle as polling.
+- You want Laniakea to register the webhook and own the local HTTP server.
+
+Production notes:
+- Set `BotWebHookOpts.SecretToken` for request authentication.
+- `BotWebHookOpts.SecretToken` is required when `BotWebHookOpts.UseStatusPath` is enabled.
+- Keep `BotWebHookOpts.Path` specific instead of serving webhook traffic on `/`.
+- If you switch an existing deployment from webhook mode to long polling, delete the webhook first with `CloseWebHook()` or `tgapi.DeleteWebhook(...)`. Telegram keeps webhook delivery active until it is removed.
+- Use `RunWebHookWithContext(...)` with a cancelable context, then call `Close()` after runtime shutdown.
+
+See the full guide in the wiki: [Webhook Runtime](https://git.scuroneko.dev/ScuroNeko/Laniakea/wiki/Webhook-Runtime)
 
 ## 📖 Core Concepts
 ### Plugins
@@ -271,7 +291,7 @@ func adminOnlyMiddleware(ctx *laniakea.MsgContext, db *MyDB) bool {
 - **Rate Limiting**: Pass a configured utils.RateLimiter via BotOpts to handle Telegram's rate limits gracefully.
 - **Localization**: `L10n` is safe for concurrent use once attached to the bot.
 - **Custom Update Handlers**: Use `plugin.AddUpdateHandler(...)` for Telegram update types that are not part of the command/payload flow.
-- **Lifecycle**: `RunWithContext(...)` does not call `Close()` for you. Shut the bot down explicitly, and create a fresh `Bot` for the next run.
+- **Lifecycle**: `RunWithContext(...)` and `RunWebHookWithContext(...)` do not call `Close()` for you. Shut the bot down explicitly, and create a fresh `Bot` for the next run.
 
 ## Telegram Update Handling
 - Commands and payloads are handled through plugins.

README_RU.md

@@ -24,6 +24,7 @@
 *   **Встроенный ограничитель запросов (Rate Limiter):** Защитите бота от превышения лимитов Telegram API (с обработкой `retry_after`).
 *   **Контекст данных:** Передавайте общие данные приложения или state в обработчики.
 *   **Настраиваемый API:** Комбинируйте `Set...` и `Add...` helper-методы для понятной конфигурации, например `bot.SetErrorTemplate(...).AddPlugins(...)`.
+*   **Polling и Webhook Runtime:** Запускайте бота через long polling с `Run()` / `RunWithContext(...)` или через webhook server, которым владеет сам бот, с `RunWebHookWithContext(...)`.
 
 ---
 
@@ -117,7 +118,26 @@ func main() {
 6. `SetErrorTemplate`: Устанавливает шаблон для сообщений об ошибках. Плейсхолдер %s заменяется на текст ошибки.
 7. `AutoGenerateCommands`: Регистрирует команды из плагинов в Telegram для поддерживаемых scope.
 8. `Run()`: Запускает цикл опроса обновлений бота и возвращает ошибку, если старт или polling завершился неуспешно.
-9. Экземпляр `Bot` одноразовый. После завершения `Run()` или `RunWithContext()` для следующего запуска создавайте новый бот.
+9. `RunWebHookWithContext(...)`: Запускает bot-owned webhook runtime, когда Telegram должен доставлять update по HTTP вместо long polling.
+10. Экземпляр `Bot` одноразовый. После завершения `Run()`, `RunWithContext()` или `RunWebHookWithContext()` для следующего запуска создавайте новый бот.
+
+## Webhook Runtime
+
+Laniakea также поддерживает bot-owned webhook runtime через `RunWebHookWithContext(...)` и `RunWebHook(...)`.
+
+Используй его, когда:
+- Telegram должен сам отправлять update на твой HTTP endpoint вместо polling.
+- Ты хочешь, чтобы webhook-update проходили через ту же внутреннюю очередь, тот же worker pool, тех же runners и тот же single-use lifecycle, что и polling.
+- Ты хочешь, чтобы Laniakea сама регистрировала webhook и владела локальным HTTP server.
+
+Практические замечания:
+- Задавай `BotWebHookOpts.SecretToken` для аутентификации запросов.
+- Непустой `BotWebHookOpts.SecretToken` обязателен, если включён `BotWebHookOpts.UseStatusPath`.
+- Используй явный `BotWebHookOpts.Path`, а не `/`.
+- Если ты переводишь уже существующий deployment с webhook-режима на long polling, сначала удали webhook через `CloseWebHook()` или `tgapi.DeleteWebhook(...)`. Пока webhook не удалён, Telegram продолжает доставку через него.
+- Запускай `RunWebHookWithContext(...)` с cancelable context и после остановки runtime всё равно вызывай `Close()`.
+
+Полное руководство есть в wiki: [Webhook Runtime](https://git.scuroneko.dev/ScuroNeko/Laniakea/wiki/Webhook-Runtime-RU)
 
 ## 📖 Основные концепции
 ### Плагины (Plugins)
@@ -268,7 +288,7 @@ func adminOnlyMiddleware(ctx *laniakea.MsgContext, db *MyDB) bool {
 - **Ограничение запросов**: Передайте настроенный `utils.RateLimiter` через `BotOpts` для корректной обработки лимитов Telegram.
 - **Локализация**: `L10n` безопасен для конкурентного использования после подключения к боту.
 - **Пользовательские update handlers**: Используйте `plugin.AddUpdateHandler(...)` для Telegram update types вне command/payload flow.
-- **Жизненный цикл**: `RunWithContext(...)` не вызывает `Close()` автоматически. Завершайте бот явно и создавайте новый `Bot` для следующего запуска.
+- **Жизненный цикл**: `RunWithContext(...)` и `RunWebHookWithContext(...)` не вызывают `Close()` автоматически. Завершайте бот явно и создавайте новый `Bot` для следующего запуска.
 
 ## Обработка Telegram Updates
 - Команды и payload-ы обрабатываются через плагины.

TODO.md

@@ -12,11 +12,12 @@ Russian page:
 
 Current priority split:
 
-- `Priority 2`: service layer and dependency graph model.
-- `Partial`: webhook runtime model, plugin composition contract.
+- `Partial`: none.
+- `Ideas`: service layer and dependency graph model, plugin composition contract.
 
 Completed former high-priority items:
 
+- `[v1.0.0-rc.14] Webhook runtime model.`
 - `[v1.0.0-rc.13] Observability model`: added first-class `Observer` events for update, command, payload, scene, policy, runner, polling, and centralized error flows, with safe event dispatch and regression coverage for the new runtime hooks.
 - `[v1.0.0-rc.13] Authorization and policy model`: added first-class `Policy[T]`, middleware integration through `RequirePolicy(...)`, plugin and bot policy registration helpers, built-in Telegram-aware policies, and composable `AllPolicies(...)`, `AnyPolicy(...)`, and `NotPolicy(...)` helpers with regression coverage.
 - `[v1.0.0-rc.13] Update schema contract`: documented and tested the normalized `MsgContext` update-routing contract, including routing categories and per-update field guarantees.

bot.go

@@ -4,9 +4,6 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"maps"
-	"reflect"
-	"strings"
 	"sync"
 	"time"
 
@@ -14,7 +11,6 @@ import (
 	"git.scuroneko.dev/scuroneko/laniakea/tgapi"
 	"git.scuroneko.dev/scuroneko/laniakea/utils"
 	"git.scuroneko.dev/scuroneko/slog"
-	"github.com/alitto/pond/v2"
 )
 
 // AppData is the generic shared application data type injected into bots,
@@ -63,7 +59,7 @@ var (
 	ErrNoPrefixes = errors.New("no prefixes defined")
 	// ErrNoPlugins reports that the bot was started without any registered plugins.
 	ErrNoPlugins = errors.New("no plugins defined")
-	// ErrBotAlreadyRun reports that Run or RunWithContext was called more than once.
+	// ErrBotAlreadyRun reports that Run, RunWithContext, or RunWebHookWithContext was called more than once.
 	ErrBotAlreadyRun = errors.New("bot can only be run once")
 
 	// ErrTokenRequired reports that BotOpts.Token was empty.
@@ -81,8 +77,10 @@ var (
 //   - Logging and rate limiting
 //   - Localization and draft message support
 //
-// Runtime accessors are safe for concurrent use. Configure the bot before Run.
-// A Bot is single-use: after Run or RunWithContext returns, create a new Bot for the next session.
+// Runtime accessors are safe for concurrent use. Configure the bot before Run,
+// RunWithContext, or RunWebHookWithContext.
+// A Bot is single-use: after Run, RunWithContext, or RunWebHookWithContext returns,
+// create a new Bot for the next session.
 type Bot[T AppData] struct {
 	token             string
 	debug             bool
@@ -94,6 +92,7 @@ type Bot[T AppData] struct {
 
 	logger        *slog.Logger                // Main bot logger (JSON stdout + optional file)
 	RequestLogger *slog.Logger                // Optional request-level API logging
+	webHookLogger *slog.Logger                // Webhook logger. Available only after Bot.RunWebHookWithContext.
 	extraLoggers  extypes.Slice[*slog.Logger] // API, Uploader, and custom loggers
 
 	plugins     []Plugin[T]     // Command/event handlers
@@ -233,39 +232,59 @@ func NewBot[T any](opts *BotOpts) (*Bot[T], error) {
 //
 // Close shuts down, in order:
 //   - Registered plugins via Plugin.Close
+//   - Webhook logger (if initialized)
 //   - Uploader (waits for pending uploads)
 //   - API client internals
 //   - RequestLogger (if enabled)
 //   - Main logger
 //
-// RunWithContext does not call Close automatically. The caller is responsible
-// for invoking Close after RunWithContext returns to release these resources.
+// RunWithContext and RunWebHookWithContext do not call Close automatically.
+// The caller is responsible for invoking Close after runtime returns to release
+// these resources.
 //
 // Close returns a joined error containing all shutdown failures, if any.
 func (bot *Bot[T]) Close() error {
 	var e []error
+	logCloseErr := func(err error) {
+		if err == nil {
+			return
+		}
+		if bot.logger != nil {
+			bot.logger.Errorln(err)
+		}
+		e = append(e, err)
+	}
 
 	for _, p := range bot.plugins {
 		if err := p.Close(); err != nil {
 			e = append(e, err)
 		}
 	}
-	if err := bot.uploader.Close(); err != nil {
-		bot.logger.Errorln(err)
-		e = append(e, err)
+	if bot.webHookLogger != nil {
+		if err := bot.webHookLogger.Close(); err != nil {
+			logCloseErr(err)
+		}
+		bot.webHookLogger = nil
 	}
-	if err := bot.api.Close(); err != nil {
-		bot.logger.Errorln(err)
-		e = append(e, err)
+	if bot.uploader != nil {
+		if err := bot.uploader.Close(); err != nil {
+			logCloseErr(err)
+		}
+	}
+	if bot.api != nil {
+		if err := bot.api.Close(); err != nil {
+			logCloseErr(err)
+		}
 	}
 	if bot.RequestLogger != nil {
 		if err := bot.RequestLogger.Close(); err != nil {
-			bot.logger.Errorln(err)
-			e = append(e, err)
+			logCloseErr(err)
 		}
 	}
-	if err := bot.logger.Close(); err != nil {
-		e = append(e, err)
+	if bot.logger != nil {
+		if err := bot.logger.Close(); err != nil {
+			e = append(e, err)
+		}
 	}
 	return errors.Join(e...)
 }
@@ -327,6 +346,10 @@ func (bot *Bot[T]) L10n(lang, key string) string {
 //   - Finishes processing currently queued updates
 //   - Waits for registered runners to exit
 //
+// If you are switching an existing deployment from webhook delivery to polling,
+// delete the current webhook first with CloseWebHook or tgapi.DeleteWebhook.
+// Telegram keeps webhook delivery active until the webhook is removed.
+//
 // RunWithContext does not close API, uploader, or logger resources on return.
 // The caller must invoke Close after RunWithContext finishes.
 //
@@ -346,8 +369,6 @@ func (bot *Bot[T]) RunWithContext(ctx context.Context) error {
 
 	bot.ExecRunners(ctx)
 
-	bot.logger.Infoln("Bot running. Press CTRL+C to exit.")
-
 	// Start update polling in a goroutine
 	go func() {
 		defer func() {
@@ -398,10 +419,7 @@ func (bot *Bot[T]) RunWithContext(ctx context.Context) error {
 				retryCount = 0
 
 				for _, update := range updates {
-					u := update // copy loop variable to avoid race condition
-					select {
-					case bot.updateQueue <- &u:
-					case <-ctx.Done():
+					if err := bot.enqueueUpdate(ctx, update); err != nil {
 						return
 					}
 				}
@@ -409,15 +427,10 @@ func (bot *Bot[T]) RunWithContext(ctx context.Context) error {
 		}
 	}()
 
+	bot.logger.Infoln("Bot running. Press CTRL+C to exit.")
 	// Start worker pool for concurrent update handling
-	pool := pond.NewPool(bot.maxWorkers)
-	for update := range bot.updateQueue {
-		u := update // capture loop variable
-		pool.Submit(func() {
-			bot.handle(ctx, u)
-		})
-	}
-	pool.Stop() // Wait for all tasks to complete and stop the pool
+	bot.startUpdateWorkers(ctx)
+
 	bot.runnerOnceWG.Wait()
 	bot.runnerBgWG.Wait()
 	return nil
@@ -432,145 +445,3 @@ func (bot *Bot[T]) RunWithContext(ctx context.Context) error {
 func (bot *Bot[T]) Run() error {
 	return bot.RunWithContext(context.Background())
 }
-
-func (bot *Bot[T]) initLoggers(opts *BotOpts) {
-	level := slog.FATAL
-	if opts.Debug {
-		level = slog.DEBUG
-	}
-
-	bot.logger = utils.CreateLogger("BOT", level)
-	if opts.WriteToFile {
-		path := fmt.Sprintf("%s/main.log", strings.TrimRight(opts.LoggerBasePath, "/"))
-		logger, err := utils.CreateFileLogger("BOT", level, path)
-		if err != nil {
-			bot.logger.Errorln(err)
-		} else {
-			bot.logger = logger
-		}
-	}
-
-	if opts.UseRequestLogger {
-		bot.RequestLogger = utils.CreateLogger("REQUESTS", level)
-		if opts.WriteToFile {
-			path := fmt.Sprintf("%s/requests.log", strings.TrimRight(opts.LoggerBasePath, "/"))
-			logger, err := utils.CreateFileLogger("REQUESTS", level, path)
-			if err != nil {
-				bot.logger.Errorln(err)
-			} else {
-				bot.RequestLogger = logger
-			}
-		}
-	}
-}
-
-func (bot *Bot[T]) beginRun() error {
-	bot.runStateMu.Lock()
-	defer bot.runStateMu.Unlock()
-	if bot.running || bot.ran {
-		return ErrBotAlreadyRun
-	}
-	bot.running = true
-	bot.ran = true
-	return nil
-}
-
-func (bot *Bot[T]) finishRun() {
-	bot.runStateMu.Lock()
-	bot.running = false
-	bot.runStateMu.Unlock()
-}
-
-func nextPollRetryDelay(prev time.Duration) time.Duration {
-	if prev <= 0 {
-		return time.Second
-	}
-	next := prev * 2
-	if next > 30*time.Second {
-		return 30 * time.Second
-	}
-	return next
-}
-
-func isNilValue[T any](v T) bool {
-	rv := reflect.ValueOf(v)
-	if !rv.IsValid() {
-		return true
-	}
-	switch rv.Kind() {
-	case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Pointer, reflect.Slice:
-		return rv.IsNil()
-	default:
-		return false
-	}
-}
-
-func shouldWarnOnValueAppData[T any]() bool {
-	t := reflect.TypeFor[T]()
-	if t == reflect.TypeFor[NoData]() {
-		return false
-	}
-	switch t.Kind() {
-	case reflect.Pointer, reflect.Interface, reflect.Map, reflect.Slice, reflect.Func, reflect.Chan:
-		return false
-	default:
-		return true
-	}
-}
-
-func clonePlugin[T AppData](p *Plugin[T]) Plugin[T] {
-	cloned := Plugin[T]{
-		name:        p.name,
-		commands:    make(map[string]*Command[T], len(p.commands)),
-		payloads:    make(map[string]*Command[T], len(p.payloads)),
-		scenes:      make(map[string]*Scene[T], len(p.scenes)),
-		middlewares: append(extypes.Slice[Middleware[T]](nil), p.middlewares...),
-		skipAutoCmd: p.skipAutoCmd,
-		logger:      p.logger,
-		handlers:    make(map[tgapi.UpdateType]CommandExecutor[T]),
-		onClose:     p.onClose,
-	}
-
-	for name, command := range p.commands {
-		cloned.commands[name] = cloneCommand(command)
-	}
-	for name, command := range p.payloads {
-		cloned.payloads[name] = cloneCommand(command)
-	}
-	for name, scene := range p.scenes {
-		cloned.scenes[name] = cloneScene(scene)
-	}
-	maps.Copy(cloned.handlers, p.handlers)
-
-	return cloned
-}
-
-func cloneCommand[T AppData](command *Command[T]) *Command[T] {
-	if command == nil {
-		return nil
-	}
-
-	cloned := *command
-	cloned.args = append(extypes.Slice[CommandArg](nil), command.args...)
-	cloned.middlewares = append(extypes.Slice[Middleware[T]](nil), command.middlewares...)
-	return &cloned
-}
-
-func cloneScene[T AppData](scene *Scene[T]) *Scene[T] {
-	if scene == nil {
-		return nil
-	}
-
-	cloned := *scene
-	cloned.steps = make(map[string]SceneHandler[T], len(scene.steps))
-	cloned.commands = make(map[string]SceneHandler[T], len(scene.commands))
-
-	for name, handler := range scene.steps {
-		cloned.steps[name] = handler
-	}
-	for name, handler := range scene.commands {
-		cloned.commands[name] = handler
-	}
-
-	return &cloned
-}

bot_config.go

@@ -9,7 +9,7 @@ import (
 )
 
 // AddPrefixes adds one or more command prefixes (e.g., "/", "!").
-// Must have at least one prefix before Run().
+// The bot must have at least one prefix before any runtime entry point starts.
 func (bot *Bot[T]) AddPrefixes(prefixes ...string) *Bot[T] {
 	if !bot.configMutable("AddPrefixes") {
 		return bot

bot_register.go

@@ -93,7 +93,8 @@ func (bot *Bot[T]) UsePolicy(name string, policy Policy[T]) *Bot[T] {
 //   - Metrics collection or health checks
 //   - Scheduled tasks (e.g., daily announcements)
 //
-// Runners are started immediately after Bot.Run() is called.
+// Runners start from the bot runtime entry points, immediately after
+// RunWithContext or RunWebHookWithContext begins.
 //
 // Example:
 //

bot_test.go

@@ -278,6 +278,41 @@ func TestRunWithContextRejectsSecondRun(t *testing.T) {
 	}
 }
 
+func TestCloseDoesNotDeleteWebhook(t *testing.T) {
+	requests := 0
+	client := &http.Client{
+		Transport: pollingRoundTripFunc(func(req *http.Request) (*http.Response, error) {
+			requests++
+			return &http.Response{
+				StatusCode: http.StatusOK,
+				Header:     http.Header{"Content-Type": []string{"application/json"}},
+				Body:       io.NopCloser(strings.NewReader(`{"ok":true,"result":true}`)),
+			}, nil
+		}),
+	}
+
+	api := tgapi.NewAPI(
+		tgapi.NewAPIOpts("token").
+			SetAPIUrl("http://example.invalid").
+			SetHTTPClient(client),
+	)
+	uploader := tgapi.NewUploader(api)
+
+	bot := &Bot[NoData]{
+		logger:        slog.CreateLogger(),
+		webHookLogger: slog.CreateLogger(),
+		api:           api,
+		uploader:      uploader,
+	}
+
+	if err := bot.Close(); err != nil {
+		t.Fatalf("Close returned error: %v", err)
+	}
+	if requests != 0 {
+		t.Fatalf("Close performed unexpected remote requests: got %d want 0", requests)
+	}
+}
+
 func TestRunWithContextEmitsPollingRetryAndErrorEvents(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()

bot_utils.go

@@ -0,0 +1,178 @@
+package laniakea
+
+import (
+	"context"
+	"fmt"
+	"maps"
+	"reflect"
+	"strings"
+	"time"
+
+	"git.scuroneko.dev/scuroneko/extypes"
+	"git.scuroneko.dev/scuroneko/laniakea/tgapi"
+	"git.scuroneko.dev/scuroneko/laniakea/utils"
+	"git.scuroneko.dev/scuroneko/slog"
+	"github.com/alitto/pond/v2"
+)
+
+func (bot *Bot[T]) enqueueUpdate(ctx context.Context, update tgapi.Update) error {
+	select {
+	case <-ctx.Done():
+		return ctx.Err()
+	case bot.updateQueue <- new(update):
+		return nil
+	}
+}
+
+func (bot *Bot[T]) startUpdateWorkers(ctx context.Context) {
+	pool := pond.NewPool(bot.maxWorkers)
+	for update := range bot.updateQueue {
+		u := update // capture loop variable
+		pool.Submit(func() {
+			bot.handle(ctx, u)
+		})
+	}
+	pool.Stop() // Wait for all tasks to complete and stop the pool
+}
+
+func (bot *Bot[T]) initLoggers(opts *BotOpts) {
+	level := slog.FATAL
+	if opts.Debug {
+		level = slog.DEBUG
+	}
+
+	bot.logger = utils.CreateLogger("BOT", level)
+	if opts.WriteToFile {
+		path := fmt.Sprintf("%s/main.log", strings.TrimRight(opts.LoggerBasePath, "/"))
+		logger, err := utils.CreateFileLogger("BOT", level, path)
+		if err != nil {
+			bot.logger.Errorln(err)
+		} else {
+			bot.logger = logger
+		}
+	}
+
+	if opts.UseRequestLogger {
+		bot.RequestLogger = utils.CreateLogger("REQUESTS", level)
+		if opts.WriteToFile {
+			path := fmt.Sprintf("%s/requests.log", strings.TrimRight(opts.LoggerBasePath, "/"))
+			logger, err := utils.CreateFileLogger("REQUESTS", level, path)
+			if err != nil {
+				bot.logger.Errorln(err)
+			} else {
+				bot.RequestLogger = logger
+			}
+		}
+	}
+}
+
+func (bot *Bot[T]) beginRun() error {
+	bot.runStateMu.Lock()
+	defer bot.runStateMu.Unlock()
+	if bot.running || bot.ran {
+		return ErrBotAlreadyRun
+	}
+	bot.running = true
+	bot.ran = true
+	return nil
+}
+
+func (bot *Bot[T]) finishRun() {
+	bot.runStateMu.Lock()
+	bot.running = false
+	bot.runStateMu.Unlock()
+}
+
+func nextPollRetryDelay(prev time.Duration) time.Duration {
+	if prev <= 0 {
+		return time.Second
+	}
+	next := prev * 2
+	if next > 30*time.Second {
+		return 30 * time.Second
+	}
+	return next
+}
+
+func isNilValue[T any](v T) bool {
+	rv := reflect.ValueOf(v)
+	if !rv.IsValid() {
+		return true
+	}
+	switch rv.Kind() {
+	case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Pointer, reflect.Slice:
+		return rv.IsNil()
+	default:
+		return false
+	}
+}
+
+func shouldWarnOnValueAppData[T any]() bool {
+	t := reflect.TypeFor[T]()
+	if t == reflect.TypeFor[NoData]() {
+		return false
+	}
+	switch t.Kind() {
+	case reflect.Pointer, reflect.Interface, reflect.Map, reflect.Slice, reflect.Func, reflect.Chan:
+		return false
+	default:
+		return true
+	}
+}
+
+func clonePlugin[T AppData](p *Plugin[T]) Plugin[T] {
+	cloned := Plugin[T]{
+		name:        p.name,
+		commands:    make(map[string]*Command[T], len(p.commands)),
+		payloads:    make(map[string]*Command[T], len(p.payloads)),
+		scenes:      make(map[string]*Scene[T], len(p.scenes)),
+		middlewares: append(extypes.Slice[Middleware[T]](nil), p.middlewares...),
+		skipAutoCmd: p.skipAutoCmd,
+		logger:      p.logger,
+		handlers:    make(map[tgapi.UpdateType]CommandExecutor[T]),
+		onClose:     p.onClose,
+	}
+
+	for name, command := range p.commands {
+		cloned.commands[name] = cloneCommand(command)
+	}
+	for name, command := range p.payloads {
+		cloned.payloads[name] = cloneCommand(command)
+	}
+	for name, scene := range p.scenes {
+		cloned.scenes[name] = cloneScene(scene)
+	}
+	maps.Copy(cloned.handlers, p.handlers)
+
+	return cloned
+}
+
+func cloneCommand[T AppData](command *Command[T]) *Command[T] {
+	if command == nil {
+		return nil
+	}
+
+	cloned := *command
+	cloned.args = append(extypes.Slice[CommandArg](nil), command.args...)
+	cloned.middlewares = append(extypes.Slice[Middleware[T]](nil), command.middlewares...)
+	return &cloned
+}
+
+func cloneScene[T AppData](scene *Scene[T]) *Scene[T] {
+	if scene == nil {
+		return nil
+	}
+
+	cloned := *scene
+	cloned.steps = make(map[string]SceneHandler[T], len(scene.steps))
+	cloned.commands = make(map[string]SceneHandler[T], len(scene.commands))
+
+	for name, handler := range scene.steps {
+		cloned.steps[name] = handler
+	}
+	for name, handler := range scene.commands {
+		cloned.commands[name] = handler
+	}
+
+	return &cloned
+}

bot_webhook.go

@@ -0,0 +1,461 @@
+package laniakea
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"strings"
+	"time"
+
+	"git.scuroneko.dev/scuroneko/laniakea/tgapi"
+	"git.scuroneko.dev/scuroneko/laniakea/utils"
+)
+
+// BotWebHookOpts configures Telegram webhook registration and the local HTTP server.
+type BotWebHookOpts struct {
+	Path          string
+	LocalPort     int
+	UseStatusPath bool
+
+	URL                string
+	Certificate        []byte
+	IPAddress          string
+	MaxConnections     int8
+	AllowedUpdates     []tgapi.UpdateType
+	DropPendingUpdates bool
+	SecretToken        string
+}
+
+// NewBotWebHookOpts returns webhook options with the default path, local port, and max connections.
+func NewBotWebHookOpts() *BotWebHookOpts {
+	return &BotWebHookOpts{
+		Path:           "/",
+		LocalPort:      8080,
+		MaxConnections: 40,
+	}
+}
+
+// SetPath sets the local HTTP path that receives Telegram webhook requests.
+func (opts *BotWebHookOpts) SetPath(path string) *BotWebHookOpts {
+	opts.Path = path
+	return opts
+}
+
+// SetLocalPort sets the local HTTP port used by the webhook server.
+func (opts *BotWebHookOpts) SetLocalPort(port int) *BotWebHookOpts {
+	opts.LocalPort = port
+	return opts
+}
+
+// SetUseStatusPath enables or disables the optional /status endpoint.
+// A non-empty SecretToken is required when this endpoint is enabled.
+func (opts *BotWebHookOpts) SetUseStatusPath(use bool) *BotWebHookOpts {
+	opts.UseStatusPath = use
+	return opts
+}
+
+// SetURL sets the public base URL Telegram should call for incoming updates.
+func (opts *BotWebHookOpts) SetURL(url string) *BotWebHookOpts {
+	opts.URL = url
+	return opts
+}
+
+// SetCertificate sets the self-signed webhook certificate bytes to upload.
+func (opts *BotWebHookOpts) SetCertificate(certificate []byte) *BotWebHookOpts {
+	opts.Certificate = certificate
+	return opts
+}
+
+// MustLoadCertificate loads a webhook certificate from disk and panics on failure.
+func (opts *BotWebHookOpts) MustLoadCertificate(filename string) *BotWebHookOpts {
+	f, err := os.Open(filename)
+	if err != nil {
+		panic(err)
+	}
+	defer func() {
+		_ = f.Close()
+	}()
+	opts.Certificate, err = io.ReadAll(f)
+	if err != nil {
+		panic(err)
+	}
+	return opts
+}
+
+// SetIPAddress sets the fixed IP address Telegram should use for webhook delivery.
+func (opts *BotWebHookOpts) SetIPAddress(ip string) *BotWebHookOpts {
+	opts.IPAddress = ip
+	return opts
+}
+
+// SetMaxConnections sets Telegram's maximum number of simultaneous webhook connections.
+func (opts *BotWebHookOpts) SetMaxConnections(max int8) *BotWebHookOpts {
+	opts.MaxConnections = max
+	return opts
+}
+
+// SetAllowedUpdates sets the Telegram update types that should be delivered to the webhook.
+func (opts *BotWebHookOpts) SetAllowedUpdates(updates ...tgapi.UpdateType) *BotWebHookOpts {
+	opts.AllowedUpdates = append([]tgapi.UpdateType(nil), updates...)
+	return opts
+}
+
+// SetDropPendingUpdates configures whether Telegram should drop pending updates while setting the webhook.
+func (opts *BotWebHookOpts) SetDropPendingUpdates(drop bool) *BotWebHookOpts {
+	opts.DropPendingUpdates = drop
+	return opts
+}
+
+// SetSecretToken sets the secret token expected in Telegram webhook requests.
+// The same token is also required to access /status when that endpoint is enabled.
+func (opts *BotWebHookOpts) SetSecretToken(secretToken string) *BotWebHookOpts {
+	opts.SecretToken = secretToken
+	return opts
+}
+
+// RunWebHookWithContext registers the webhook and serves incoming updates until ctx is canceled.
+//
+// The bot uses the same update queue, worker pool, runner startup, and single-use lifecycle
+// guarantees as RunWithContext. When opts.AllowedUpdates is empty, the bot-level update types
+// configured through SetUpdateTypes/AddUpdateType are used. When UseStatusPath is enabled,
+// SecretToken must be non-empty so the operational endpoint is not left public.
+//
+// When two TLS files are provided, the method serves HTTPS using the existing key-then-cert
+// argument order.
+func (bot *Bot[T]) RunWebHookWithContext(ctx context.Context, opts *BotWebHookOpts, tlsFiles ...string) error {
+	if opts == nil {
+		return errors.New("nil BotWebHookOpts")
+	}
+	if len(bot.prefixes) == 0 {
+		return ErrNoPrefixes
+	}
+	if len(bot.plugins) == 0 {
+		return ErrNoPlugins
+	}
+	if opts.URL == "" {
+		return errors.New("empty BotWebHookOpts.URL")
+	}
+	if opts.MaxConnections > 100 || opts.MaxConnections <= 0 {
+		return errors.New("BotWebHookOpts.MaxConnections must between 1 and 100")
+	}
+	if err := validateWebhookPath(opts.Path, opts.UseStatusPath); err != nil {
+		return err
+	}
+	if opts.UseStatusPath && opts.SecretToken == "" {
+		return errors.New("BotWebHookOpts.SecretToken required when status path is enabled")
+	}
+	if err := validateWebhookTLSFiles(tlsFiles); err != nil {
+		return err
+	}
+
+	bot.webHookLogger = utils.CreateLogger("WEBHOOK", bot.GetLoggerLevel())
+	if opts.SecretToken == "" {
+		bot.webHookLogger.Warnln("Bot webhook secret token empty. It's VERY recommended to set secret.")
+	}
+
+	if opts.Certificate != nil && bot.uploader == nil {
+		return errors.New("bot uploader nil, but certificate set")
+	}
+
+	return bot.runWebhookRuntime(ctx, func(runCtx context.Context) error {
+		i, err := bot.api.GetWebhookInfoWithContext(runCtx)
+		if err != nil {
+			return err
+		}
+		if i.URL == "" {
+			bot.webHookLogger.Warnln("API returned webhook info with empty URL. There may be a long-poll")
+		} else {
+			_, err = bot.api.DeleteWebhookWithContext(runCtx, tgapi.DeleteWebhook{})
+			if err != nil {
+				return err
+			}
+			bot.webHookLogger.Infof("Bot webhook deleted: %s", i.URL)
+		}
+
+		allowedUpdates := bot.webhookAllowedUpdates(opts)
+
+		var ok bool
+		if opts.Certificate != nil {
+			ok, err = bot.uploader.SetWebhookWithContext(runCtx, tgapi.UploadSetWebhook{
+				URL:                fmt.Sprintf("%s%s", opts.URL, opts.Path),
+				IPAddress:          opts.IPAddress,
+				MaxConnections:     opts.MaxConnections,
+				AllowedUpdates:     allowedUpdates,
+				DropPendingUpdates: opts.DropPendingUpdates,
+				SecretToken:        opts.SecretToken,
+			}, tgapi.NewUploaderFile("certificate", opts.Certificate))
+		} else {
+			ok, err = bot.api.SetWebhookWithContext(runCtx, tgapi.SetWebhook{
+				URL:                fmt.Sprintf("%s%s", opts.URL, opts.Path),
+				IPAddress:          opts.IPAddress,
+				MaxConnections:     opts.MaxConnections,
+				AllowedUpdates:     allowedUpdates,
+				DropPendingUpdates: opts.DropPendingUpdates,
+				SecretToken:        opts.SecretToken,
+			})
+		}
+		if err != nil {
+			return err
+		}
+		if !ok {
+			return errors.New("failed to set webhook")
+		}
+
+		if len(tlsFiles) == 2 {
+			return bot.runWebHookTLS(runCtx, opts, tlsFiles[0], tlsFiles[1])
+		}
+
+		return bot.runWebHook(runCtx, opts)
+	})
+}
+
+// RunWebHook starts the webhook runtime with a background context.
+//
+// It is shorthand for RunWebHookWithContext(context.Background(), opts, tlsFiles...).
+func (bot *Bot[T]) RunWebHook(opts *BotWebHookOpts, tlsFiles ...string) error {
+	return bot.RunWebHookWithContext(context.Background(), opts, tlsFiles...)
+}
+
+// CloseWebHook removes the current Telegram webhook registration.
+//
+// It is separate from Close, which only releases local resources.
+// Call it before switching a deployment from webhook delivery to polling.
+func (bot *Bot[T]) CloseWebHook() error {
+	var e []error
+	if bot.api == nil {
+		e = append(e, errors.New("bot api nil"))
+	} else {
+		if _, err := bot.api.DeleteWebhook(tgapi.DeleteWebhook{}); err != nil {
+			if bot.webHookLogger != nil {
+				bot.webHookLogger.Errorf("Failed to close webhook: %s", err.Error())
+			} else if bot.logger != nil {
+				bot.logger.Errorf("Failed to close webhook: %s", err.Error())
+			}
+			e = append(e, err)
+		}
+	}
+	if bot.webHookLogger != nil {
+		if err := bot.webHookLogger.Close(); err != nil {
+			e = append(e, err)
+		}
+		bot.webHookLogger = nil
+	}
+	return errors.Join(e...)
+}
+
+func (bot *Bot[T]) webhookAllowedUpdates(opts *BotWebHookOpts) []tgapi.UpdateType {
+	if len(opts.AllowedUpdates) > 0 {
+		return append([]tgapi.UpdateType(nil), opts.AllowedUpdates...)
+	}
+	return bot.GetUpdateTypes()
+}
+
+func (bot *Bot[T]) runWebhookRuntime(ctx context.Context, run func(context.Context) error) error {
+	if err := bot.beginRun(); err != nil {
+		return err
+	}
+	defer bot.finishRun()
+
+	runCtx, cancel := context.WithCancel(ctx)
+	defer cancel()
+
+	bot.ExecRunners(runCtx)
+
+	workersDone := make(chan struct{})
+	go func() {
+		bot.startUpdateWorkers(runCtx)
+		close(workersDone)
+	}()
+
+	runErr := run(runCtx)
+	cancel()
+	close(bot.updateQueue)
+	<-workersDone
+	bot.runnerOnceWG.Wait()
+	bot.runnerBgWG.Wait()
+
+	return runErr
+}
+
+func updateHandler[T any](ctx context.Context, bot *Bot[T], secret string) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		defer func() {
+			_ = r.Body.Close()
+		}()
+		if r.Method != http.MethodPost {
+			w.WriteHeader(http.StatusMethodNotAllowed)
+			return
+		}
+		if secret != "" && r.Header.Get("X-Telegram-Bot-Api-Secret-Token") != secret {
+			w.WriteHeader(http.StatusForbidden)
+			return
+		}
+
+		const maxWebhookBodySize = 256 << 10 // 256 KiB
+		r.Body = http.MaxBytesReader(w, r.Body, maxWebhookBodySize)
+
+		data, err := io.ReadAll(r.Body)
+		if err != nil {
+			if _, ok := errors.AsType[*http.MaxBytesError](err); ok {
+				w.WriteHeader(http.StatusRequestEntityTooLarge)
+				return
+			}
+			w.WriteHeader(http.StatusBadRequest)
+			return
+		}
+		if len(data) == 0 {
+			w.WriteHeader(http.StatusBadRequest)
+			return
+		}
+		var up tgapi.Update
+		if err := json.Unmarshal(data, &up); err != nil {
+			w.WriteHeader(http.StatusBadRequest)
+			bot.webHookLogger.Errorln(err)
+			return
+		}
+		bot.webHookLogger.Debugf("UPDATE id=%d type=%s size=%d from=%s", up.UpdateID, up.Type, len(data), r.RemoteAddr)
+		if err := bot.enqueueUpdate(ctx, up); err != nil {
+			bot.webHookLogger.Errorln(err)
+			w.WriteHeader(http.StatusServiceUnavailable)
+			return
+		}
+		w.WriteHeader(http.StatusOK)
+	}
+}
+
+func statusHandler[T any](bot *Bot[T], opts *BotWebHookOpts) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		auth := ""
+		if r.Header.Get("Authorization") != "" {
+			auth = r.Header.Get("Authorization")
+		} else if r.Header.Get("X-Telegram-Bot-Api-Secret-Token") != "" {
+			auth = r.Header.Get("X-Telegram-Bot-Api-Secret-Token")
+		}
+		if auth != opts.SecretToken {
+			w.WriteHeader(http.StatusNotFound)
+			return
+		}
+
+		i, err := bot.api.GetWebhookInfoWithContext(r.Context())
+		if err != nil {
+			bot.webHookLogger.Errorln(err)
+			w.WriteHeader(http.StatusInternalServerError)
+			return
+		}
+		data, err := json.MarshalIndent(i, "", "  ")
+		if err != nil {
+			bot.webHookLogger.Errorln(err)
+			w.WriteHeader(http.StatusInternalServerError)
+			return
+		}
+		w.Header().Set("Content-Type", "application/json")
+		if _, err := fmt.Fprint(w, string(data)); err != nil {
+			bot.webHookLogger.Errorln(err)
+		}
+	}
+}
+
+func (bot *Bot[T]) newWebHookMux(ctx context.Context, opts *BotWebHookOpts) *http.ServeMux {
+	r := http.NewServeMux()
+	if opts.UseStatusPath {
+		r.HandleFunc("/status", statusHandler[T](bot, opts))
+	}
+	r.HandleFunc(opts.Path, updateHandler[T](ctx, bot, opts.SecretToken))
+	return r
+}
+func (bot *Bot[T]) runWebHook(ctx context.Context, opts *BotWebHookOpts) error {
+	srv := &http.Server{
+		Addr:    fmt.Sprintf(":%d", opts.LocalPort),
+		Handler: bot.newWebHookMux(ctx, opts),
+	}
+	errCh := make(chan error, 1)
+
+	go func() {
+		err := srv.ListenAndServe()
+		if err != nil && !errors.Is(err, http.ErrServerClosed) {
+			errCh <- err
+			return
+		}
+		errCh <- nil
+	}()
+
+	bot.webHookLogger.Infoln(fmt.Sprintf("Bot WebHook started at %s; waiting for updates at %s", srv.Addr, opts.URL))
+
+	select {
+	case <-ctx.Done():
+		shutdownCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+		defer cancel()
+
+		if err := srv.Shutdown(shutdownCtx); err != nil {
+			return err
+		}
+
+		return <-errCh
+
+	case err := <-errCh:
+		return err
+	}
+}
+func (bot *Bot[T]) runWebHookTLS(ctx context.Context, opts *BotWebHookOpts, key, cert string) error {
+	srv := &http.Server{
+		Addr:    fmt.Sprintf(":%d", opts.LocalPort),
+		Handler: bot.newWebHookMux(ctx, opts),
+	}
+	errCh := make(chan error, 1)
+
+	go func() {
+		err := srv.ListenAndServeTLS(cert, key)
+		if err != nil && !errors.Is(err, http.ErrServerClosed) {
+			errCh <- err
+			return
+		}
+		errCh <- nil
+	}()
+
+	bot.webHookLogger.Infoln(fmt.Sprintf("Bot webhook started with TLS(%s, %s) at %s; waiting for updates at %s", key, cert, srv.Addr, opts.URL))
+
+	select {
+	case <-ctx.Done():
+		shutdownCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+		defer cancel()
+
+		if err := srv.Shutdown(shutdownCtx); err != nil {
+			return err
+		}
+
+		return <-errCh
+
+	case err := <-errCh:
+		return err
+	}
+}
+func validateWebhookPath(path string, useStatusPath bool) error {
+	if path == "" {
+		return errors.New("empty BotWebHookOpts.Path")
+	}
+	if !strings.HasPrefix(path, "/") {
+		return errors.New("BotWebHookOpts.Path must start with '/'")
+	}
+	if strings.Contains(path, "?") || strings.Contains(path, "#") {
+		return errors.New("BotWebHookOpts.Path must not contain query or fragment")
+	}
+	if useStatusPath && path == "/status" {
+		return errors.New("BotWebHookOpts.Path must not be '/status' when status path is enabled")
+	}
+	return nil
+}
+
+func validateWebhookTLSFiles(tlsFiles []string) error {
+	switch len(tlsFiles) {
+	case 0, 2:
+		return nil
+	case 1:
+		return errors.New("you must specify both private and public keys")
+	default:
+		return errors.New("too many files; you must specify only private and public keys")
+	}
+}

bot_webhook_test.go

@@ -0,0 +1,293 @@
+package laniakea
+
+import (
+	"context"
+	"errors"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"sync/atomic"
+	"testing"
+
+	"git.scuroneko.dev/scuroneko/laniakea/tgapi"
+	"git.scuroneko.dev/scuroneko/slog"
+)
+
+func TestEnqueueUpdateCopiesValue(t *testing.T) {
+	bot := &Bot[NoData]{
+		updateQueue: make(chan *tgapi.Update, 1),
+	}
+
+	update := tgapi.Update{UpdateID: 42}
+	if err := bot.enqueueUpdate(context.Background(), update); err != nil {
+		t.Fatalf("enqueueUpdate returned error: %v", err)
+	}
+
+	update.UpdateID = 99
+
+	got := <-bot.updateQueue
+	if got.UpdateID != 42 {
+		t.Fatalf("enqueueUpdate did not copy the update value: got %d want %d", got.UpdateID, 42)
+	}
+}
+
+func TestUpdateHandlerEnqueuesUpdate(t *testing.T) {
+	bot := &Bot[NoData]{
+		updateQueue:   make(chan *tgapi.Update, 1),
+		webHookLogger: slog.CreateLogger(),
+	}
+	t.Cleanup(func() {
+		_ = bot.webHookLogger.Close()
+	})
+
+	req := httptest.NewRequest(http.MethodPost, "/", strings.NewReader(`{"update_id":7,"message":{"message_id":1,"date":1,"chat":{"id":1,"type":"private"},"text":"/start"}}`))
+	req.Header.Set("X-Telegram-Bot-Api-Secret-Token", "secret")
+	rec := httptest.NewRecorder()
+
+	updateHandler(context.Background(), bot, "secret").ServeHTTP(rec, req)
+
+	if rec.Result().StatusCode != http.StatusOK {
+		t.Fatalf("unexpected status: got %d want %d", rec.Result().StatusCode, http.StatusOK)
+	}
+
+	select {
+	case got := <-bot.updateQueue:
+		if got.UpdateID != 7 {
+			t.Fatalf("unexpected update id in queue: got %d want %d", got.UpdateID, 7)
+		}
+		if got.Type != tgapi.UpdateTypeMessage {
+			t.Fatalf("unexpected update type in queue: got %q want %q", got.Type, tgapi.UpdateTypeMessage)
+		}
+	default:
+		t.Fatal("expected webhook handler to enqueue an update")
+	}
+}
+
+func TestRunWebhookRuntimeRejectsSecondRun(t *testing.T) {
+	bot := &Bot[NoData]{
+		logger:      slog.CreateLogger(),
+		updateQueue: make(chan *tgapi.Update, 1),
+		maxWorkers:  1,
+	}
+	t.Cleanup(func() {
+		_ = bot.logger.Close()
+	})
+
+	if err := bot.runWebhookRuntime(context.Background(), func(context.Context) error { return nil }); err != nil {
+		t.Fatalf("first runWebhookRuntime returned error: %v", err)
+	}
+	if err := bot.runWebhookRuntime(context.Background(), func(context.Context) error { return nil }); !errors.Is(err, ErrBotAlreadyRun) {
+		t.Fatalf("expected ErrBotAlreadyRun on second run, got %v", err)
+	}
+}
+
+func TestRunWebhookRuntimeExecutesRunners(t *testing.T) {
+	var calls atomic.Int32
+
+	bot := &Bot[NoData]{
+		logger:      slog.CreateLogger(),
+		updateQueue: make(chan *tgapi.Update, 1),
+		maxWorkers:  1,
+		runners: []Runner[NoData]{
+			NewRunner("runner", func(bot *Bot[NoData]) error {
+				calls.Add(1)
+				return nil
+			}).Onetime(true).Async(false),
+		},
+	}
+	t.Cleanup(func() {
+		_ = bot.logger.Close()
+	})
+
+	if err := bot.runWebhookRuntime(context.Background(), func(context.Context) error { return nil }); err != nil {
+		t.Fatalf("runWebhookRuntime returned error: %v", err)
+	}
+	if got := calls.Load(); got != 1 {
+		t.Fatalf("expected runner to execute once, got %d", got)
+	}
+}
+
+func TestWebhookAllowedUpdatesUsesBotUpdateTypesByDefault(t *testing.T) {
+	bot := &Bot[NoData]{
+		updateTypes: []tgapi.UpdateType{tgapi.UpdateTypeMessage, tgapi.UpdateTypeCallbackQuery},
+	}
+	opts := NewBotWebHookOpts()
+
+	got := bot.webhookAllowedUpdates(opts)
+	if len(got) != 2 {
+		t.Fatalf("unexpected allowed updates length: got %d want %d", len(got), 2)
+	}
+	if got[0] != tgapi.UpdateTypeMessage || got[1] != tgapi.UpdateTypeCallbackQuery {
+		t.Fatalf("unexpected allowed updates: %v", got)
+	}
+
+	got[0] = tgapi.UpdateTypePoll
+	if bot.updateTypes[0] != tgapi.UpdateTypeMessage {
+		t.Fatalf("webhookAllowedUpdates exposed internal slice: got %v", bot.updateTypes)
+	}
+}
+
+func TestValidateWebhookPath(t *testing.T) {
+	tests := []struct {
+		name          string
+		path          string
+		useStatusPath bool
+		wantErr       bool
+	}{
+		{name: "root", path: "/", wantErr: false},
+		{name: "custom path", path: "/telegram", wantErr: false},
+		{name: "empty", path: "", wantErr: true},
+		{name: "missing slash", path: "telegram", wantErr: true},
+		{name: "query", path: "/telegram?x=1", wantErr: true},
+		{name: "fragment", path: "/telegram#main", wantErr: true},
+		{name: "status collision", path: "/status", useStatusPath: true, wantErr: true},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			err := validateWebhookPath(tc.path, tc.useStatusPath)
+			if tc.wantErr && err == nil {
+				t.Fatal("expected error, got nil")
+			}
+			if !tc.wantErr && err != nil {
+				t.Fatalf("unexpected error: %v", err)
+			}
+		})
+	}
+}
+
+func TestValidateWebhookTLSFiles(t *testing.T) {
+	tests := []struct {
+		name    string
+		files   []string
+		wantErr bool
+	}{
+		{name: "no tls", files: nil, wantErr: false},
+		{name: "two files", files: []string{"key.pem", "cert.pem"}, wantErr: false},
+		{name: "one file", files: []string{"cert.pem"}, wantErr: true},
+		{name: "three files", files: []string{"a", "b", "c"}, wantErr: true},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			err := validateWebhookTLSFiles(tc.files)
+			if tc.wantErr && err == nil {
+				t.Fatal("expected error, got nil")
+			}
+			if !tc.wantErr && err != nil {
+				t.Fatalf("unexpected error: %v", err)
+			}
+		})
+	}
+}
+
+func TestUpdateHandlerRejectsOversizedBody(t *testing.T) {
+	bot := &Bot[NoData]{
+		updateQueue:   make(chan *tgapi.Update, 1),
+		webHookLogger: slog.CreateLogger(),
+	}
+	t.Cleanup(func() {
+		_ = bot.webHookLogger.Close()
+	})
+
+	req := httptest.NewRequest(http.MethodPost, "/", strings.NewReader(strings.Repeat("a", (256<<10)+1)))
+	rec := httptest.NewRecorder()
+
+	updateHandler(context.Background(), bot, "").ServeHTTP(rec, req)
+
+	if rec.Result().StatusCode != http.StatusRequestEntityTooLarge {
+		t.Fatalf("unexpected status: got %d want %d", rec.Result().StatusCode, http.StatusRequestEntityTooLarge)
+	}
+}
+
+func TestStatusHandlerRequiresMatchingSecret(t *testing.T) {
+	client := &http.Client{
+		Transport: pollingRoundTripFunc(func(req *http.Request) (*http.Response, error) {
+			return &http.Response{
+				StatusCode: http.StatusOK,
+				Header:     http.Header{"Content-Type": []string{"application/json"}},
+				Body:       io.NopCloser(strings.NewReader(`{"ok":true,"result":{"url":"https://bot.example.com/telegram"}}`)),
+			}, nil
+		}),
+	}
+	api := tgapi.NewAPI(
+		tgapi.NewAPIOpts("token").
+			SetAPIUrl("http://example.invalid").
+			SetHTTPClient(client),
+	)
+	defer func() {
+		_ = api.Close()
+	}()
+
+	bot := &Bot[NoData]{
+		api:           api,
+		webHookLogger: slog.CreateLogger(),
+	}
+	t.Cleanup(func() {
+		_ = bot.webHookLogger.Close()
+	})
+
+	handler := statusHandler(bot, &BotWebHookOpts{SecretToken: "secret"})
+
+	tests := []struct {
+		name       string
+		headerName string
+		headerVal  string
+		wantStatus int
+	}{
+		{name: "missing auth", wantStatus: http.StatusNotFound},
+		{name: "wrong auth", headerName: "Authorization", headerVal: "wrong", wantStatus: http.StatusNotFound},
+		{name: "matching telegram header", headerName: "X-Telegram-Bot-Api-Secret-Token", headerVal: "secret", wantStatus: http.StatusOK},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			req := httptest.NewRequest(http.MethodGet, "/status", nil)
+			if tc.headerName != "" {
+				req.Header.Set(tc.headerName, tc.headerVal)
+			}
+			rec := httptest.NewRecorder()
+
+			handler.ServeHTTP(rec, req)
+
+			if rec.Result().StatusCode != tc.wantStatus {
+				t.Fatalf("unexpected status: got %d want %d", rec.Result().StatusCode, tc.wantStatus)
+			}
+		})
+	}
+}
+
+func TestRunWebHookWithContextRejectsInvalidTLSFilesBeforeRemoteSetup(t *testing.T) {
+	bot := &Bot[NoData]{
+		prefixes: []string{"/"},
+		plugins:  []Plugin[NoData]{{name: "demo"}},
+	}
+	opts := NewBotWebHookOpts().SetURL("https://bot.example.com")
+
+	err := bot.RunWebHookWithContext(context.Background(), opts, "cert.pem")
+	if err == nil {
+		t.Fatal("expected tls validation error, got nil")
+	}
+	if !strings.Contains(err.Error(), "both private and public keys") {
+		t.Fatalf("unexpected error: %v", err)
+	}
+}
+
+func TestRunWebHookWithContextRequiresSecretWhenStatusPathEnabled(t *testing.T) {
+	bot := &Bot[NoData]{
+		prefixes: []string{"/"},
+		plugins:  []Plugin[NoData]{{name: "demo"}},
+	}
+	opts := NewBotWebHookOpts().
+		SetURL("https://bot.example.com").
+		SetUseStatusPath(true)
+
+	err := bot.RunWebHookWithContext(context.Background(), opts)
+	if err == nil {
+		t.Fatal("expected status-path secret validation error, got nil")
+	}
+	if !strings.Contains(err.Error(), "SecretToken required") {
+		t.Fatalf("unexpected error: %v", err)
+	}
+}

cmd_generator.go

@@ -112,7 +112,7 @@ func (bot *Bot[T]) AutoGenerateCommands() error {
 	}
 
 	// Clear existing commands to avoid duplication or stale entries
-	_, err := bot.api.DeleteMyCommands(tgapi.DeleteMyCommandsP{})
+	_, err := bot.api.DeleteMyCommands(tgapi.DeleteMyCommands{})
 	if err != nil {
 		return fmt.Errorf("failed to delete existing commands: %w", err)
 	}
@@ -125,7 +125,7 @@ func (bot *Bot[T]) AutoGenerateCommands() error {
 	}
 
 	for _, scope := range scopes {
-		_, err = bot.api.SetMyCommands(tgapi.SetMyCommandsP{
+		_, err = bot.api.SetMyCommands(tgapi.SetMyCommands{
 			Commands: commands,
 			Scope:    scope,
 		})
@@ -159,12 +159,12 @@ func (bot *Bot[T]) AutoGenerateCommandsForScope(scope *tgapi.BotCommandScope) er
 		return ErrTooManyCommands
 	}
 
-	_, err := bot.api.DeleteMyCommands(tgapi.DeleteMyCommandsP{Scope: scope})
+	_, err := bot.api.DeleteMyCommands(tgapi.DeleteMyCommands{Scope: scope})
 	if err != nil {
 		return fmt.Errorf("failed to delete existing commands: %w", err)
 	}
 
-	_, err = bot.api.SetMyCommands(tgapi.SetMyCommandsP{
+	_, err = bot.api.SetMyCommands(tgapi.SetMyCommands{
 		Commands: commands,
 		Scope:    scope,
 	})

doc.go

@@ -27,7 +27,7 @@ Example usage:
 
 	return bot.Run()
 
-Configure bots, plugins, and localization before starting Run or RunWithContext.
+Configure bots, plugins, and localization before starting Run, RunWithContext, or RunWebHookWithContext.
 Runtime accessors are safe for concurrent use unless stated otherwise.
 */
 package laniakea

drafts.go

@@ -221,7 +221,7 @@ func (d *Draft) Flush() error {
 		return err
 	}
 
-	params := tgapi.SendMessageP{
+	params := tgapi.SendMessage{
 		ChatID:    d.chatID,
 		ParseMode: d.parseMode,
 		Entities:  d.entities,
@@ -247,7 +247,7 @@ func (d *Draft) push(text string) error {
 	if err := validateMessageText(d.Message); err != nil {
 		return err
 	}
-	params := tgapi.SendMessageDraftP{
+	params := tgapi.SendMessageDraft{
 		ChatID:    d.chatID,
 		DraftID:   d.ID,
 		Text:      d.Message,

handler_test.go

@@ -9,10 +9,6 @@ import (
 	"git.scuroneko.dev/scuroneko/slog"
 )
 
-func ptr[T any](v T) *T {
-	return &v
-}
-
 type recordingObserver struct {
 	started  []HandlerStartedEvent
 	finished []HandlerFinishedEvent
@@ -230,7 +226,7 @@ func TestPrepareUpdateCtxContract(t *testing.T) {
 				CallbackQuery: &tgapi.CallbackQuery{
 					ID:              "cb-2",
 					From:            tgapi.User{ID: 107},
-					InlineMessageID: ptr("inline-42"),
+					InlineMessageID: new("inline-42"),
 				},
 			},
 			wantFrom:        true,
@@ -907,7 +903,7 @@ func TestHandleCallbackPopulatesInlineTargets(t *testing.T) {
 			ID:              "cb-inline",
 			Data:            data,
 			From:            tgapi.User{ID: 8},
-			InlineMessageID: ptr("inline-55"),
+			InlineMessageID: new("inline-55"),
 		},
 	})
 

keyboard.go

@@ -147,6 +147,8 @@ func (in *InlineKeyboard) SetPayloadType(t BotPayloadType) *InlineKeyboard {
 // GetPayloadType returns the keyboard-local callback payload encoding type.
 func (in *InlineKeyboard) GetPayloadType() BotPayloadType { return in.payloadType }
 
+// SetMaxRow sets the maximum number of buttons appended to a row before the
+// keyboard automatically starts a new line.
 func (in *InlineKeyboard) SetMaxRow(maxRow int) *InlineKeyboard {
 	in.maxRow = maxRow
 	return in

methods.go

@@ -43,8 +43,8 @@ import (
 func (bot *Bot[T]) Updates(ctx context.Context) ([]tgapi.Update, error) {
 	offset := bot.GetUpdateOffset()
 	params := tgapi.UpdateParams{
-		Offset:         Ptr(offset),
-		Timeout:        Ptr(30),
+		Offset:         new(offset),
+		Timeout:        new(30),
 		AllowedUpdates: bot.GetUpdateTypes(),
 	}
 

msg_context.go

@@ -100,7 +100,7 @@ func (ctx *MsgContext) edit(messageId int, text string, keyboard *InlineKeyboard
 		ctx.Logger.Errorln(err)
 		return nil
 	}
-	params := tgapi.EditMessageTextP{
+	params := tgapi.EditMessageText{
 		Text:      text,
 		ParseMode: parseMode,
 	}
@@ -184,7 +184,7 @@ func (ctx *MsgContext) editPhotoText(messageId int, text string, kb *InlineKeybo
 		ctx.Logger.Errorln(err)
 		return nil
 	}
-	params := tgapi.EditMessageCaptionP{
+	params := tgapi.EditMessageCaption{
 		Caption:   text,
 		ParseMode: parseMode,
 	}
@@ -250,7 +250,7 @@ func (ctx *MsgContext) answer(text string, keyboard *InlineKeyboard, parseMode t
 		ctx.Logger.Errorln(err)
 		return nil
 	}
-	params := tgapi.SendMessageP{
+	params := tgapi.SendMessage{
 		ChatID:    ctx.Msg.Chat.ID,
 		Text:      text,
 		ParseMode: parseMode,
@@ -380,7 +380,7 @@ func (ctx *MsgContext) answerPhoto(photoId, text string, kb *InlineKeyboard, par
 		ctx.Logger.Errorln(err)
 		return nil
 	}
-	params := tgapi.SendPhotoP{
+	params := tgapi.SendPhoto{
 		ChatID:    ctx.Msg.Chat.ID,
 		Caption:   text,
 		ParseMode: parseMode,
@@ -452,7 +452,7 @@ func (ctx *MsgContext) delete(messageId int) {
 		ctx.Logger.Errorln(ErrMessageContextNil)
 		return
 	}
-	_, err := ctx.Api.DeleteMessageWithContext(ctx.Context(), tgapi.DeleteMessageP{
+	_, err := ctx.Api.DeleteMessageWithContext(ctx.Context(), tgapi.DeleteMessage{
 		ChatID:    ctx.Msg.Chat.ID,
 		MessageID: messageId,
 	})
@@ -478,7 +478,7 @@ func (ctx *MsgContext) answerCallbackQuery(url, text string, showAlert bool) {
 	if len(ctx.CallbackQueryId) == 0 {
 		return
 	}
-	_, err := ctx.Api.AnswerCallbackQueryWithContext(ctx.Context(), tgapi.AnswerCallbackQueryP{
+	_, err := ctx.Api.AnswerCallbackQueryWithContext(ctx.Context(), tgapi.AnswerCallbackQuery{
 		CallbackQueryID: ctx.CallbackQueryId,
 		Text:            text, ShowAlert: showAlert, URL: url,
 	})
@@ -505,7 +505,7 @@ func (ctx *MsgContext) SendAction(action tgapi.ChatActionType) {
 		ctx.Logger.Errorln("Can't send action without chat message context")
 		return
 	}
-	params := tgapi.SendChatActionP{
+	params := tgapi.SendChatAction{
 		ChatID: ctx.Msg.Chat.ID, Action: action,
 	}
 	if ctx.Msg.MessageThreadID > 0 {

observer.go

@@ -32,6 +32,7 @@ const (
 	HandlerSceneMessageKind HandlerEventKind = "scene_message"
 )
 
+// Event is the marker interface implemented by all observer runtime events.
 type Event interface {
 	isEvent()
 }

plugins.go

@@ -18,7 +18,7 @@ const (
 	CommandValueStringType CommandValueType = "string"
 	// CommandValueIntType expects a decimal integer (digits only).
 	CommandValueIntType CommandValueType = "int"
-	// CommandValueBoolType is reserved for future use (not implemented).
+	// CommandValueBoolType expects a exact "true" or "false".
 	CommandValueBoolType CommandValueType = "bool"
 	// CommandValueAnyType accepts any input without validation.
 	CommandValueAnyType CommandValueType = "any"
@@ -193,6 +193,12 @@ func NewPlugin[T AppData](name string) *Plugin[T] {
 // AddCommand registers a command in the plugin.
 // The command's .command field is used as the key.
 func (p *Plugin[T]) AddCommand(command *Command[T]) *Plugin[T] {
+	if command == nil {
+		if p.logger != nil {
+			p.logger.Warnln("trying to add nil command")
+		}
+		return p
+	}
 	p.commands[command.command] = command
 	return p
 }
@@ -208,6 +214,12 @@ func (p *Plugin[T]) NewCommand(exec CommandExecutor[T], command string, args ...
 // AddPayload registers a payload (e.g., callback query data) in the plugin.
 // Payloads are triggered by inline button callback_data, not by message text.
 func (p *Plugin[T]) AddPayload(command *Command[T]) *Plugin[T] {
+	if command == nil {
+		if p.logger != nil {
+			p.logger.Warnln("trying to add nil command")
+		}
+		return p
+	}
 	p.payloads[command.command] = command
 	return p
 }

policy.go

@@ -143,7 +143,7 @@ func RequireChatAdmin[T AppData]() Policy[T] {
 			return AsInternalError(errors.New("chat-admin policy requires message chat context"))
 		}
 
-		member, err := ctx.Api.GetChatMember(tgapi.GetChatMemberP{
+		member, err := ctx.Api.GetChatMember(tgapi.GetChatMember{
 			ChatID: ctx.ChatID,
 			UserID: ctx.FromID,
 		})
@@ -166,7 +166,7 @@ func RequireChatCreator[T AppData]() Policy[T] {
 			return AsInternalError(errors.New("chat-creator policy requires message chat context"))
 		}
 
-		member, err := ctx.Api.GetChatMember(tgapi.GetChatMemberP{
+		member, err := ctx.Api.GetChatMember(tgapi.GetChatMember{
 			ChatID: ctx.ChatID,
 			UserID: ctx.FromID,
 		})
@@ -194,7 +194,7 @@ func RequireBotAdmin[T AppData]() Policy[T] {
 			return AsInternalError(fmt.Errorf("failed to fetch bot info: %w", err))
 		}
 
-		member, err := ctx.Api.GetChatMember(tgapi.GetChatMemberP{
+		member, err := ctx.Api.GetChatMember(tgapi.GetChatMember{
 			ChatID: ctx.ChatID,
 			UserID: bot.ID,
 		})

runners.go

@@ -88,7 +88,8 @@ func (r Runner[T]) Timeout(timeout time.Duration) Runner[T] {
 //
 // Background runners listen for ctx.Done() and gracefully shut down when the context is canceled.
 //
-// This method is typically called once during bot startup in RunWithContext.
+// This method is typically called once during bot startup from RunWithContext or
+// RunWebHookWithContext.
 func (bot *Bot[T]) ExecRunners(ctx context.Context) {
 	bot.logger.Infoln("Executing runners...")
 	for _, runner := range bot.runners {

tgapi/api.go

@@ -98,6 +98,11 @@ type API struct {
 // Always call Close() when done to release resources.
 func NewAPI(opts *APIOpts) *API {
 	l := utils.CreateLogger("API", utils.GetLoggerLevel())
+	if opts == nil {
+		l.Errorln("Set API options")
+		_ = l.Close()
+		return nil
+	}
 
 	client := opts.client
 	if client == nil {

tgapi/attachments_methods.go

@@ -2,9 +2,9 @@ package tgapi
 
 import "context"
 
-// SendPhotoP holds parameters for the sendPhoto method.
+// SendPhoto holds parameters for the sendPhoto method.
 // See https://core.telegram.org/bots/api#sendphoto
-type SendPhotoP struct {
+type SendPhoto struct {
 	BusinessConnectionID  string `json:"business_connection_id,omitempty"`
 	ChatID                int64  `json:"chat_id"`
 	MessageThreadID       int    `json:"message_thread_id,omitempty"`
@@ -29,7 +29,7 @@ type SendPhotoP struct {
 
 // SendPhoto sends a photo.
 // See https://core.telegram.org/bots/api#sendphoto
-func (api *API) SendPhoto(params SendPhotoP) (Message, error) {
+func (api *API) SendPhoto(params SendPhoto) (Message, error) {
 	req := NewRequestWithChatID[Message]("sendPhoto", params, params.ChatID)
 	return req.Do(api)
 }
@@ -37,14 +37,14 @@ func (api *API) SendPhoto(params SendPhotoP) (Message, error) {
 // SendPhotoWithContext is the context-aware variant of SendPhoto.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#sendphoto
-func (api *API) SendPhotoWithContext(ctx context.Context, params SendPhotoP) (Message, error) {
+func (api *API) SendPhotoWithContext(ctx context.Context, params SendPhoto) (Message, error) {
 	req := NewRequestWithChatID[Message]("sendPhoto", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
 
-// SendAudioP holds parameters for the sendAudio method.
+// SendAudio holds parameters for the sendAudio method.
 // See https://core.telegram.org/bots/api#sendaudio
-type SendAudioP struct {
+type SendAudio struct {
 	BusinessConnectionID  string `json:"business_connection_id,omitempty"`
 	ChatID                int64  `json:"chat_id"`
 	MessageThreadID       int    `json:"message_thread_id,omitempty"`
@@ -71,7 +71,7 @@ type SendAudioP struct {
 
 // SendAudio sends an audio file.
 // See https://core.telegram.org/bots/api#sendaudio
-func (api *API) SendAudio(params SendAudioP) (Message, error) {
+func (api *API) SendAudio(params SendAudio) (Message, error) {
 	req := NewRequestWithChatID[Message]("sendAudio", params, params.ChatID)
 	return req.Do(api)
 }
@@ -79,14 +79,14 @@ func (api *API) SendAudio(params SendAudioP) (Message, error) {
 // SendAudioWithContext is the context-aware variant of SendAudio.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#sendaudio
-func (api *API) SendAudioWithContext(ctx context.Context, params SendAudioP) (Message, error) {
+func (api *API) SendAudioWithContext(ctx context.Context, params SendAudio) (Message, error) {
 	req := NewRequestWithChatID[Message]("sendAudio", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
 
-// SendDocumentP holds parameters for the sendDocument method.
+// SendDocument holds parameters for the sendDocument method.
 // See https://core.telegram.org/bots/api#senddocument
-type SendDocumentP struct {
+type SendDocument struct {
 	BusinessConnectionID  string `json:"business_connection_id,omitempty"`
 	ChatID                int64  `json:"chat_id"`
 	MessageThreadID       int    `json:"message_thread_id,omitempty"`
@@ -111,7 +111,7 @@ type SendDocumentP struct {
 
 // SendDocument sends a document.
 // See https://core.telegram.org/bots/api#senddocument
-func (api *API) SendDocument(params SendDocumentP) (Message, error) {
+func (api *API) SendDocument(params SendDocument) (Message, error) {
 	req := NewRequestWithChatID[Message]("sendDocument", params, params.ChatID)
 	return req.Do(api)
 }
@@ -119,14 +119,14 @@ func (api *API) SendDocument(params SendDocumentP) (Message, error) {
 // SendDocumentWithContext is the context-aware variant of SendDocument.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#senddocument
-func (api *API) SendDocumentWithContext(ctx context.Context, params SendDocumentP) (Message, error) {
+func (api *API) SendDocumentWithContext(ctx context.Context, params SendDocument) (Message, error) {
 	req := NewRequestWithChatID[Message]("sendDocument", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
 
-// SendVideoP holds parameters for the sendVideo method.
+// SendVideo holds parameters for the sendVideo method.
 // See https://core.telegram.org/bots/api#sendvideo
-type SendVideoP struct {
+type SendVideo struct {
 	BusinessConnectionID  string `json:"business_connection_id,omitempty"`
 	ChatID                int64  `json:"chat_id"`
 	MessageThreadID       int    `json:"message_thread_id,omitempty"`
@@ -159,7 +159,7 @@ type SendVideoP struct {
 
 // SendVideo sends a video.
 // See https://core.telegram.org/bots/api#sendvideo
-func (api *API) SendVideo(params SendVideoP) (Message, error) {
+func (api *API) SendVideo(params SendVideo) (Message, error) {
 	req := NewRequestWithChatID[Message]("sendVideo", params, params.ChatID)
 	return req.Do(api)
 }
@@ -167,14 +167,14 @@ func (api *API) SendVideo(params SendVideoP) (Message, error) {
 // SendVideoWithContext is the context-aware variant of SendVideo.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#sendvideo
-func (api *API) SendVideoWithContext(ctx context.Context, params SendVideoP) (Message, error) {
+func (api *API) SendVideoWithContext(ctx context.Context, params SendVideo) (Message, error) {
 	req := NewRequestWithChatID[Message]("sendVideo", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
 
-// SendAnimationP holds parameters for the sendAnimation method.
+// SendAnimation holds parameters for the sendAnimation method.
 // See https://core.telegram.org/bots/api#sendanimation
-type SendAnimationP struct {
+type SendAnimation struct {
 	BusinessConnectionID  string `json:"business_connection_id,omitempty"`
 	ChatID                int64  `json:"chat_id"`
 	MessageThreadID       int    `json:"message_thread_id,omitempty"`
@@ -203,7 +203,7 @@ type SendAnimationP struct {
 
 // SendAnimation sends an animation file (GIF or H.264/MPEG-4 AVC video without sound).
 // See https://core.telegram.org/bots/api#sendanimation
-func (api *API) SendAnimation(params SendAnimationP) (Message, error) {
+func (api *API) SendAnimation(params SendAnimation) (Message, error) {
 	req := NewRequestWithChatID[Message]("sendAnimation", params, params.ChatID)
 	return req.Do(api)
 }
@@ -211,14 +211,14 @@ func (api *API) SendAnimation(params SendAnimationP) (Message, error) {
 // SendAnimationWithContext is the context-aware variant of SendAnimation.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#sendanimation
-func (api *API) SendAnimationWithContext(ctx context.Context, params SendAnimationP) (Message, error) {
+func (api *API) SendAnimationWithContext(ctx context.Context, params SendAnimation) (Message, error) {
 	req := NewRequestWithChatID[Message]("sendAnimation", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
 
-// SendVoiceP holds parameters for the sendVoice method.
+// SendVoice holds parameters for the sendVoice method.
 // See https://core.telegram.org/bots/api#sendvoice
-type SendVoiceP struct {
+type SendVoice struct {
 	BusinessConnectionID  string `json:"business_connection_id,omitempty"`
 	ChatID                int64  `json:"chat_id"`
 	MessageThreadID       int    `json:"message_thread_id,omitempty"`
@@ -241,7 +241,7 @@ type SendVoiceP struct {
 
 // SendVoice sends a voice note.
 // See https://core.telegram.org/bots/api#sendvoice
-func (api *API) SendVoice(params SendVoiceP) (Message, error) {
+func (api *API) SendVoice(params SendVoice) (Message, error) {
 	req := NewRequestWithChatID[Message]("sendVoice", params, params.ChatID)
 	return req.Do(api)
 }
@@ -249,14 +249,14 @@ func (api *API) SendVoice(params SendVoiceP) (Message, error) {
 // SendVoiceWithContext is the context-aware variant of SendVoice.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#sendvoice
-func (api *API) SendVoiceWithContext(ctx context.Context, params SendVoiceP) (Message, error) {
+func (api *API) SendVoiceWithContext(ctx context.Context, params SendVoice) (Message, error) {
 	req := NewRequestWithChatID[Message]("sendVoice", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
 
-// SendVideoNoteP holds parameters for the sendVideoNote method.
+// SendVideoNote holds parameters for the sendVideoNote method.
 // See https://core.telegram.org/bots/api#sendvideonote
-type SendVideoNoteP struct {
+type SendVideoNote struct {
 	BusinessConnectionID  string `json:"business_connection_id,omitempty"`
 	ChatID                int64  `json:"chat_id"`
 	MessageThreadID       int    `json:"message_thread_id,omitempty"`
@@ -278,7 +278,7 @@ type SendVideoNoteP struct {
 
 // SendVideoNote sends a video note (rounded video message).
 // See https://core.telegram.org/bots/api#sendvideonote
-func (api *API) SendVideoNote(params SendVideoNoteP) (Message, error) {
+func (api *API) SendVideoNote(params SendVideoNote) (Message, error) {
 	req := NewRequestWithChatID[Message]("sendVideoNote", params, params.ChatID)
 	return req.Do(api)
 }
@@ -286,14 +286,14 @@ func (api *API) SendVideoNote(params SendVideoNoteP) (Message, error) {
 // SendVideoNoteWithContext is the context-aware variant of SendVideoNote.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#sendvideonote
-func (api *API) SendVideoNoteWithContext(ctx context.Context, params SendVideoNoteP) (Message, error) {
+func (api *API) SendVideoNoteWithContext(ctx context.Context, params SendVideoNote) (Message, error) {
 	req := NewRequestWithChatID[Message]("sendVideoNote", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
 
-// SendPaidMediaP holds parameters for the sendPaidMedia method.
+// SendPaidMedia holds parameters for the sendPaidMedia method.
 // See https://core.telegram.org/bots/api#sendpaidmedia
-type SendPaidMediaP struct {
+type SendPaidMedia struct {
 	BusinessConnectionID  string `json:"business_connection_id,omitempty"`
 	ChatID                int64  `json:"chat_id"`
 	MessageThreadID       int    `json:"message_thread_id,omitempty"`
@@ -317,7 +317,7 @@ type SendPaidMediaP struct {
 
 // SendPaidMedia sends paid media.
 // See https://core.telegram.org/bots/api#sendpaidmedia
-func (api *API) SendPaidMedia(params SendPaidMediaP) (Message, error) {
+func (api *API) SendPaidMedia(params SendPaidMedia) (Message, error) {
 	req := NewRequestWithChatID[Message]("sendPaidMedia", params, params.ChatID)
 	return req.Do(api)
 }
@@ -325,14 +325,14 @@ func (api *API) SendPaidMedia(params SendPaidMediaP) (Message, error) {
 // SendPaidMediaWithContext is the context-aware variant of SendPaidMedia.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#sendpaidmedia
-func (api *API) SendPaidMediaWithContext(ctx context.Context, params SendPaidMediaP) (Message, error) {
+func (api *API) SendPaidMediaWithContext(ctx context.Context, params SendPaidMedia) (Message, error) {
 	req := NewRequestWithChatID[Message]("sendPaidMedia", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
 
-// SendMediaGroupP holds parameters for the sendMediaGroup method.
+// SendMediaGroup holds parameters for the sendMediaGroup method.
 // See https://core.telegram.org/bots/api#sendmediagroup
-type SendMediaGroupP struct {
+type SendMediaGroup struct {
 	BusinessConnectionID  string `json:"business_connection_id,omitempty"`
 	ChatID                int64  `json:"chat_id"`
 	MessageThreadID       int    `json:"message_thread_id,omitempty"`
@@ -348,7 +348,7 @@ type SendMediaGroupP struct {
 
 // SendMediaGroup sends a group of photos, videos, documents or audios as an album.
 // See https://core.telegram.org/bots/api#sendmediagroup
-func (api *API) SendMediaGroup(params SendMediaGroupP) ([]Message, error) {
+func (api *API) SendMediaGroup(params SendMediaGroup) ([]Message, error) {
 	req := NewRequestWithChatID[[]Message]("sendMediaGroup", params, params.ChatID)
 	return req.Do(api)
 }
@@ -356,7 +356,7 @@ func (api *API) SendMediaGroup(params SendMediaGroupP) ([]Message, error) {
 // SendMediaGroupWithContext is the context-aware variant of SendMediaGroup.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#sendmediagroup
-func (api *API) SendMediaGroupWithContext(ctx context.Context, params SendMediaGroupP) ([]Message, error) {
+func (api *API) SendMediaGroupWithContext(ctx context.Context, params SendMediaGroup) ([]Message, error) {
 	req := NewRequestWithChatID[[]Message]("sendMediaGroup", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }

tgapi/attachments_types.go

@@ -1,5 +1,253 @@
 package tgapi
 
+type Animation struct {
+	FileID       string `json:"file_id"`
+	FileUniqueID string `json:"file_unique_id"`
+	Width        int    `json:"width"`
+	Height       int    `json:"height"`
+	Duration     int    `json:"duration"`
+
+	Thumbnail *PhotoSize `json:"thumbnail,omitempty"`
+	FileName  string     `json:"file_name"`
+	MimeType  string     `json:"mime_type"`
+	FileSize  int        `json:"file_size"`
+}
+
+// Audio represents an audio file to be treated as music by the Telegram clients.
+// See https://core.telegram.org/bots/api#audio
+type Audio struct {
+	FileID       string `json:"file_id"`
+	FileUniqueID string `json:"file_unique_id"`
+	Duration     int    `json:"duration"`
+
+	Performer string     `json:"performer,omitempty"`
+	Title     string     `json:"title,omitempty"`
+	FileName  string     `json:"file_name,omitempty"`
+	MimeType  string     `json:"mime_type,omitempty"`
+	FileSize  int64      `json:"file_size,omitempty"`
+	Thumbnail *PhotoSize `json:"thumbnail,omitempty"`
+}
+
+type Document struct {
+	FileID       string     `json:"file_id"`
+	FileUniqueID string     `json:"file_unique_id"`
+	Thumbnail    *PhotoSize `json:"thumbnail,omitempty"`
+	FileName     string     `json:"file_name"`
+	MimeType     string     `json:"mime_type"`
+	FileSize     int        `json:"file_size,omitempty"`
+}
+
+// Story represents a story.
+type Story struct {
+	Chat Chat `json:"chat"`
+	ID   int  `json:"id"`
+}
+
+type Video struct {
+	FileID       string `json:"file_id"`
+	FileUniqueID string `json:"file_unique_id"`
+	Width        int    `json:"width"`
+	Height       int    `json:"height"`
+	Duration     int    `json:"duration"`
+
+	Thumbnail      *PhotoSize     `json:"thumbnail,omitempty"`
+	Cover          []PhotoSize    `json:"cover,omitempty"`
+	StartTimestamp int64          `json:"start_timestamp"`
+	Qualities      []VideoQuality `json:"qualities,omitempty"`
+	FileName       string         `json:"file_name,omitempty"`
+	MimeType       string         `json:"mime_type,omitempty"`
+	FileSize       int64          `json:"file_size,omitempty"`
+}
+
+// VideoQuality describes an alternative quality for a video.
+// See https://core.telegram.org/bots/api#videoquality
+type VideoQuality struct {
+	FileID       string `json:"file_id"`
+	FileUniqueID string `json:"file_unique_id"`
+	Width        int    `json:"width"`
+	Height       int    `json:"height"`
+	Codec        string `json:"codec"`
+	FileSize     int64  `json:"file_size,omitempty"`
+}
+
+type VideoNote struct {
+	FileID       string     `json:"file_id"`
+	FileUniqueID string     `json:"file_unique_id"`
+	Length       int        `json:"length"`
+	Duration     int        `json:"duration"`
+	Thumbnail    *PhotoSize `json:"thumbnail,omitempty"`
+	FileSize     int64      `json:"file_size,omitempty"`
+}
+
+type Voice struct {
+	FileID       string `json:"file_id"`
+	FileUniqueID string `json:"file_unique_id"`
+	Duration     int    `json:"duration"`
+	MimeType     string `json:"mime_type,omitempty"`
+	FileSize     int    `json:"file_size,omitempty"`
+}
+
+type PaidMediaInfo struct {
+	StarCount int         `json:"star_count"`
+	PaidMedia []PaidMedia `json:"paid_media"`
+}
+type PaidMediaType string
+
+const (
+	PaidMediaPreviewType PaidMediaType = "preview"
+	PaidMediaPhotoType   PaidMediaType = "photo"
+	PaidMediaVideoType   PaidMediaType = "video"
+)
+
+type PaidMedia struct {
+	Type PaidMediaType `json:"type,omitempty"`
+
+	Width    int `json:"width,omitempty"`
+	Height   int `json:"height,omitempty"`
+	Duration int `json:"duration,omitempty"`
+
+	Photo []PhotoSize `json:"photo,omitempty"`
+
+	Video *Video `json:"video,omitempty"`
+}
+
+type Contact struct {
+	PhoneNumber string `json:"phone_number"`
+	FirstName   string `json:"first_name"`
+	LastName    string `json:"last_name,omitempty"`
+	UserID      int64  `json:"user_id,omitempty"`
+	Vcard       string `json:"vcard,omitempty"`
+}
+
+type Dice struct {
+	Emoji string `json:"emoji"`
+	Value int    `json:"value"`
+}
+
+// PollOption contains information about one answer option in a poll.
+// See https://core.telegram.org/bots/api#polloption
+type PollOption struct {
+	PersistentID string          `json:"persistent_id"`
+	Text         string          `json:"text"`
+	TextEntities []MessageEntity `json:"text_entities"`
+	VoterCount   int             `json:"voter_count"`
+
+	AddedByUser  *User `json:"added_by_user,omitempty"`
+	AddedByChat  *Chat `json:"added_by_chat,omitempty"`
+	AdditionDate int   `json:"addition_date,omitempty"`
+}
+
+// InputPollOption contains information about one answer option in a poll to be sent.
+// See https://core.telegram.org/bots/api#inputpolloption
+type InputPollOption struct {
+	Text          string          `json:"text"`
+	TextParseMode ParseMode       `json:"text_parse_mode,omitempty"`
+	TextEntities  []MessageEntity `json:"text_entities,omitempty"`
+}
+
+type PollOptionAdded struct {
+	PollMessage        *InaccessibleMessage `json:"poll_message,omitempty"`
+	OptionPersistentID string               `json:"option_persistent_id"`
+	OptionText         string               `json:"option_text"`
+	OptionTextEntities []MessageEntity      `json:"option_text_entities,omitempty"`
+}
+
+type PollOptionDeleted struct {
+	PollMessage        *InaccessibleMessage `json:"poll_message,omitempty"`
+	OptionPersistentID string               `json:"option_persistent_id"`
+	OptionText         string               `json:"option_text"`
+	OptionTextEntities []MessageEntity      `json:"option_text_entities,omitempty"`
+}
+
+// PollType represents the type of a poll.
+type PollType string
+
+const (
+	// PollTypeRegular identifies a regular poll.
+	PollTypeRegular PollType = "regular"
+	// PollTypeQuiz identifies a quiz poll.
+	PollTypeQuiz PollType = "quiz"
+)
+
+// PollAnswer represents an answer of a user in a poll.
+// See https://core.telegram.org/bots/api#pollanswer
+type PollAnswer struct {
+	PollID              string   `json:"poll_id"`
+	VoterChat           Chat     `json:"voter_chat"`
+	User                User     `json:"user"`
+	OptionIDs           []int    `json:"option_ids"`
+	OptionPersistentIDs []string `json:"option_persistent_ids"`
+}
+
+// Poll contains information about a poll.
+// See https://core.telegram.org/bots/api#poll
+type Poll struct {
+	ID               string          `json:"id"`
+	Question         string          `json:"question"`
+	QuestionEntities []MessageEntity `json:"question_entities"`
+	Options          []PollOption    `json:"options"`
+	TotalVoterCount  int             `json:"total_voter_count"`
+	IsClosed         bool            `json:"is_closed"`
+	IsAnonymous      bool            `json:"is_anonymous"`
+	Type             PollType        `json:"type"`
+
+	AllowsMultipleAnswers bool            `json:"allows_multiple_answers"`
+	AllowsRevoting        bool            `json:"allows_revoting"`
+	CorrectOptionIDs      []int           `json:"correct_option_ids,omitempty"`
+	Explanation           string          `json:"explanation,omitempty"`
+	ExplanationEntities   []MessageEntity `json:"explanation_entities,omitempty"`
+	OpenPeriod            int             `json:"open_period,omitempty"`
+	CloseDate             int             `json:"close_date,omitempty"`
+	Description           string          `json:"description,omitempty"`
+	DescriptionEntities   []MessageEntity `json:"description_entities,omitempty"`
+}
+
+type ChecklistTask struct {
+	ID              int             `json:"id"`
+	Text            string          `json:"text"`
+	TextEntities    []MessageEntity `json:"text_entities,omitempty"`
+	CompletedByUser *User           `json:"completed_by_user,omitempty"`
+	CompletedByChat *Chat           `json:"completed_by_chat,omitempty"`
+	CompletionDate  int             `json:"completion_date,omitempty"`
+}
+
+type Checklist struct {
+	Title                    string          `json:"title"`
+	TitleEntities            []MessageEntity `json:"title_entities,omitempty"`
+	Tasks                    []ChecklistTask `json:"tasks"`
+	OthersCanAddTasks        bool            `json:"others_can_add_tasks,omitempty"`
+	OthersCanMarkTasksAsDone bool            `json:"others_can_mark_tasks_as_done,omitempty"`
+}
+
+// InputChecklistTask describes a task in a checklist.
+type InputChecklistTask struct {
+	ID           int             `json:"id"`
+	Text         string          `json:"text"`
+	ParseMode    ParseMode       `json:"parse_mode,omitempty"`
+	TextEntities []MessageEntity `json:"text_entities,omitempty"`
+}
+
+// InputChecklist represents a checklist to be sent.
+type InputChecklist struct {
+	Title                   string               `json:"title"`
+	ParseMode               ParseMode            `json:"parse_mode,omitempty"`
+	TitleEntities           []MessageEntity      `json:"title_entities,omitempty"`
+	Tasks                   []InputChecklistTask `json:"tasks"`
+	OtherCanAddTasks        bool                 `json:"other_can_add_tasks,omitempty"`
+	OtherCanMarkTasksAsDone bool                 `json:"other_can_mark_tasks_as_done,omitempty"`
+}
+
+type ChecklistTaskDone struct {
+	ChecklistMessage       *Message `json:"checklist_message,omitempty"`
+	MarkedAsDoneTaskIDs    []int    `json:"marked_as_done_task_ids,omitempty"`
+	MarkedAsNotDoneTaskIDs []int    `json:"marked_as_not_done_task_ids,omitempty"`
+}
+
+type ChecklistTasksAdded struct {
+	ChecklistMessage *Message        `json:"checklist_message,omitempty"`
+	Tasks            []ChecklistTask `json:"tasks"`
+}
+
 // InputMediaType represents the type of input media.
 type InputMediaType string
 

tgapi/bot_methods.go

@@ -2,9 +2,9 @@ package tgapi
 
 import "context"
 
-// SetMyCommandsP holds parameters for the setMyCommands method.
+// SetMyCommands holds parameters for the setMyCommands method.
 // See https://core.telegram.org/bots/api#setmycommands
-type SetMyCommandsP struct {
+type SetMyCommands struct {
 	Commands []BotCommand     `json:"commands"`
 	Scope    *BotCommandScope `json:"scope,omitempty"`
 	Language string           `json:"language_code,omitempty"`
@@ -13,7 +13,7 @@ type SetMyCommandsP struct {
 // SetMyCommands changes the list of the bot's commands.
 // Returns true on success.
 // See https://core.telegram.org/bots/api#setmycommands
-func (api *API) SetMyCommands(params SetMyCommandsP) (bool, error) {
+func (api *API) SetMyCommands(params SetMyCommands) (bool, error) {
 	req := NewRequest[bool]("setMyCommands", params)
 	return req.Do(api)
 }
@@ -21,14 +21,14 @@ func (api *API) SetMyCommands(params SetMyCommandsP) (bool, error) {
 // SetMyCommandsWithContext is the context-aware variant of SetMyCommands.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#setmycommands
-func (api *API) SetMyCommandsWithContext(ctx context.Context, params SetMyCommandsP) (bool, error) {
+func (api *API) SetMyCommandsWithContext(ctx context.Context, params SetMyCommands) (bool, error) {
 	req := NewRequest[bool]("setMyCommands", params)
 	return req.DoWithContext(ctx, api)
 }
 
-// DeleteMyCommandsP holds parameters for the deleteMyCommands method.
+// DeleteMyCommands holds parameters for the deleteMyCommands method.
 // See https://core.telegram.org/bots/api#deletemycommands
-type DeleteMyCommandsP struct {
+type DeleteMyCommands struct {
 	Scope    *BotCommandScope `json:"scope,omitempty"`
 	Language string           `json:"language_code,omitempty"`
 }
@@ -36,7 +36,7 @@ type DeleteMyCommandsP struct {
 // DeleteMyCommands deletes the list of the bot's commands for the given scope and user language.
 // Returns true on success.
 // See https://core.telegram.org/bots/api#deletemycommands
-func (api *API) DeleteMyCommands(params DeleteMyCommandsP) (bool, error) {
+func (api *API) DeleteMyCommands(params DeleteMyCommands) (bool, error) {
 	req := NewRequest[bool]("deleteMyCommands", params)
 	return req.Do(api)
 }
@@ -44,7 +44,7 @@ func (api *API) DeleteMyCommands(params DeleteMyCommandsP) (bool, error) {
 // DeleteMyCommandsWithContext is the context-aware variant of DeleteMyCommands.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#deletemycommands
-func (api *API) DeleteMyCommandsWithContext(ctx context.Context, params DeleteMyCommandsP) (bool, error) {
+func (api *API) DeleteMyCommandsWithContext(ctx context.Context, params DeleteMyCommands) (bool, error) {
 	req := NewRequest[bool]("deleteMyCommands", params)
 	return req.DoWithContext(ctx, api)
 }
@@ -203,16 +203,16 @@ func (api *API) GetMyShortDescriptionWithContext(ctx context.Context, params Get
 	return req.DoWithContext(ctx, api)
 }
 
-// SetMyProfilePhotoP holds parameters for the setMyProfilePhoto method.
+// SetMyProfilePhoto holds parameters for the setMyProfilePhoto method.
 // See https://core.telegram.org/bots/api#setmyprofilephoto
-type SetMyProfilePhotoP struct {
+type SetMyProfilePhoto struct {
 	Photo InputProfilePhoto `json:"photo"`
 }
 
 // SetMyProfilePhoto changes the bot's profile photo.
 // Returns true on success.
 // See https://core.telegram.org/bots/api#setmyprofilephoto
-func (api *API) SetMyProfilePhoto(params SetMyProfilePhotoP) (bool, error) {
+func (api *API) SetMyProfilePhoto(params SetMyProfilePhoto) (bool, error) {
 	req := NewRequest[bool]("setMyProfilePhoto", params)
 	return req.Do(api)
 }
@@ -220,7 +220,7 @@ func (api *API) SetMyProfilePhoto(params SetMyProfilePhotoP) (bool, error) {
 // SetMyProfilePhotoWithContext is the context-aware variant of SetMyProfilePhoto.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#setmyprofilephoto
-func (api *API) SetMyProfilePhotoWithContext(ctx context.Context, params SetMyProfilePhotoP) (bool, error) {
+func (api *API) SetMyProfilePhotoWithContext(ctx context.Context, params SetMyProfilePhoto) (bool, error) {
 	req := NewRequest[bool]("setMyProfilePhoto", params)
 	return req.DoWithContext(ctx, api)
 }
@@ -241,17 +241,17 @@ func (api *API) RemoveMyProfilePhotoWithContext(ctx context.Context) (bool, erro
 	return req.DoWithContext(ctx, api)
 }
 
-// SetChatMenuButtonP holds parameters for the setChatMenuButton method.
+// SetChatMenuButton holds parameters for the setChatMenuButton method.
 // See https://core.telegram.org/bots/api#setchatmenubutton
-type SetChatMenuButtonP struct {
-	ChatID     int64          `json:"chat_id,omitempty"`
-	MenuButton MenuButtonType `json:"menu_button"`
+type SetChatMenuButton struct {
+	ChatID     int64       `json:"chat_id,omitempty"`
+	MenuButton *MenuButton `json:"menu_button,omitempty"`
 }
 
 // SetChatMenuButton changes the menu button for a given chat or the default menu button.
 // Returns true on success.
 // See https://core.telegram.org/bots/api#setchatmenubutton
-func (api *API) SetChatMenuButton(params SetChatMenuButtonP) (bool, error) {
+func (api *API) SetChatMenuButton(params SetChatMenuButton) (bool, error) {
 	req := NewRequest[bool]("setChatMenuButton", params)
 	return req.Do(api)
 }
@@ -259,20 +259,20 @@ func (api *API) SetChatMenuButton(params SetChatMenuButtonP) (bool, error) {
 // SetChatMenuButtonWithContext is the context-aware variant of SetChatMenuButton.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#setchatmenubutton
-func (api *API) SetChatMenuButtonWithContext(ctx context.Context, params SetChatMenuButtonP) (bool, error) {
+func (api *API) SetChatMenuButtonWithContext(ctx context.Context, params SetChatMenuButton) (bool, error) {
 	req := NewRequest[bool]("setChatMenuButton", params)
 	return req.DoWithContext(ctx, api)
 }
 
-// GetChatMenuButtonP holds parameters for the getChatMenuButton method.
+// GetChatMenuButton holds parameters for the getChatMenuButton method.
 // See https://core.telegram.org/bots/api#getchatmenubutton
-type GetChatMenuButtonP struct {
+type GetChatMenuButton struct {
 	ChatID int64 `json:"chat_id,omitempty"`
 }
 
 // GetChatMenuButton returns the current menu button for the given chat.
 // See https://core.telegram.org/bots/api#getchatmenubutton
-func (api *API) GetChatMenuButton(params GetChatMenuButtonP) (MenuButton, error) {
+func (api *API) GetChatMenuButton(params GetChatMenuButton) (MenuButton, error) {
 	req := NewRequest[MenuButton]("getChatMenuButton", params)
 	return req.Do(api)
 }
@@ -280,14 +280,14 @@ func (api *API) GetChatMenuButton(params GetChatMenuButtonP) (MenuButton, error)
 // GetChatMenuButtonWithContext is the context-aware variant of GetChatMenuButton.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#getchatmenubutton
-func (api *API) GetChatMenuButtonWithContext(ctx context.Context, params GetChatMenuButtonP) (MenuButton, error) {
+func (api *API) GetChatMenuButtonWithContext(ctx context.Context, params GetChatMenuButton) (MenuButton, error) {
 	req := NewRequest[MenuButton]("getChatMenuButton", params)
 	return req.DoWithContext(ctx, api)
 }
 
-// SetMyDefaultAdministratorRightsP holds parameters for the setMyDefaultAdministratorRights method.
+// SetMyDefaultAdministratorRights holds parameters for the setMyDefaultAdministratorRights method.
 // See https://core.telegram.org/bots/api#setmydefaultadministratorrights
-type SetMyDefaultAdministratorRightsP struct {
+type SetMyDefaultAdministratorRights struct {
 	Rights      *ChatAdministratorRights `json:"rights"`
 	ForChannels bool                     `json:"for_channels"`
 }
@@ -295,7 +295,7 @@ type SetMyDefaultAdministratorRightsP struct {
 // SetMyDefaultAdministratorRights changes the default administrator rights for the bot.
 // Returns true on success.
 // See https://core.telegram.org/bots/api#setmydefaultadministratorrights
-func (api *API) SetMyDefaultAdministratorRights(params SetMyDefaultAdministratorRightsP) (bool, error) {
+func (api *API) SetMyDefaultAdministratorRights(params SetMyDefaultAdministratorRights) (bool, error) {
 	req := NewRequest[bool]("setMyDefaultAdministratorRights", params)
 	return req.Do(api)
 }
@@ -303,20 +303,20 @@ func (api *API) SetMyDefaultAdministratorRights(params SetMyDefaultAdministrator
 // SetMyDefaultAdministratorRightsWithContext is the context-aware variant of SetMyDefaultAdministratorRights.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#setmydefaultadministratorrights
-func (api *API) SetMyDefaultAdministratorRightsWithContext(ctx context.Context, params SetMyDefaultAdministratorRightsP) (bool, error) {
+func (api *API) SetMyDefaultAdministratorRightsWithContext(ctx context.Context, params SetMyDefaultAdministratorRights) (bool, error) {
 	req := NewRequest[bool]("setMyDefaultAdministratorRights", params)
 	return req.DoWithContext(ctx, api)
 }
 
-// GetMyDefaultAdministratorRightsP holds parameters for the getMyDefaultAdministratorRights method.
+// GetMyDefaultAdministratorRights holds parameters for the getMyDefaultAdministratorRights method.
 // See https://core.telegram.org/bots/api#getmydefaultadministratorrights
-type GetMyDefaultAdministratorRightsP struct {
+type GetMyDefaultAdministratorRights struct {
 	ForChannels bool `json:"for_channels"`
 }
 
 // GetMyDefaultAdministratorRights returns the current default administrator rights for the bot.
 // See https://core.telegram.org/bots/api#getmydefaultadministratorrights
-func (api *API) GetMyDefaultAdministratorRights(params GetMyDefaultAdministratorRightsP) (ChatAdministratorRights, error) {
+func (api *API) GetMyDefaultAdministratorRights(params GetMyDefaultAdministratorRights) (ChatAdministratorRights, error) {
 	req := NewRequest[ChatAdministratorRights]("getMyDefaultAdministratorRights", params)
 	return req.Do(api)
 }
@@ -324,7 +324,7 @@ func (api *API) GetMyDefaultAdministratorRights(params GetMyDefaultAdministrator
 // GetMyDefaultAdministratorRightsWithContext is the context-aware variant of GetMyDefaultAdministratorRights.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#getmydefaultadministratorrights
-func (api *API) GetMyDefaultAdministratorRightsWithContext(ctx context.Context, params GetMyDefaultAdministratorRightsP) (ChatAdministratorRights, error) {
+func (api *API) GetMyDefaultAdministratorRightsWithContext(ctx context.Context, params GetMyDefaultAdministratorRights) (ChatAdministratorRights, error) {
 	req := NewRequest[ChatAdministratorRights]("getMyDefaultAdministratorRights", params)
 	return req.DoWithContext(ctx, api)
 }
@@ -344,9 +344,9 @@ func (api *API) GetAvailableGiftsWithContext(ctx context.Context) (Gifts, error)
 	return req.DoWithContext(ctx, api)
 }
 
-// SendGiftP holds parameters for the sendGift method.
+// SendGift holds parameters for the sendGift method.
 // See https://core.telegram.org/bots/api#sendgift
-type SendGiftP struct {
+type SendGift struct {
 	UserID        int64           `json:"user_id,omitempty"`
 	ChatID        int64           `json:"chat_id,omitempty"`
 	GiftID        string          `json:"gift_id"`
@@ -359,7 +359,7 @@ type SendGiftP struct {
 // SendGift sends a gift to the given user or chat.
 // Returns true on success.
 // See https://core.telegram.org/bots/api#sendgift
-func (api *API) SendGift(params SendGiftP) (bool, error) {
+func (api *API) SendGift(params SendGift) (bool, error) {
 	req := NewRequest[bool]("sendGift", params)
 	return req.Do(api)
 }
@@ -367,14 +367,14 @@ func (api *API) SendGift(params SendGiftP) (bool, error) {
 // SendGiftWithContext is the context-aware variant of SendGift.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#sendgift
-func (api *API) SendGiftWithContext(ctx context.Context, params SendGiftP) (bool, error) {
+func (api *API) SendGiftWithContext(ctx context.Context, params SendGift) (bool, error) {
 	req := NewRequest[bool]("sendGift", params)
 	return req.DoWithContext(ctx, api)
 }
 
-// GiftPremiumSubscriptionP holds parameters for the giftPremiumSubscription method.
+// GiftPremiumSubscription holds parameters for the giftPremiumSubscription method.
 // See https://core.telegram.org/bots/api#giftpremiumsubscription
-type GiftPremiumSubscriptionP struct {
+type GiftPremiumSubscription struct {
 	UserID        int64           `json:"user_id"`
 	MonthCount    int             `json:"month_count"`
 	StarCount     int             `json:"star_count"`
@@ -386,7 +386,7 @@ type GiftPremiumSubscriptionP struct {
 // GiftPremiumSubscription gifts a Telegram Premium subscription to the user.
 // Returns true on success.
 // See https://core.telegram.org/bots/api#giftpremiumsubscription
-func (api *API) GiftPremiumSubscription(params GiftPremiumSubscriptionP) (bool, error) {
+func (api *API) GiftPremiumSubscription(params GiftPremiumSubscription) (bool, error) {
 	req := NewRequest[bool]("giftPremiumSubscription", params)
 	return req.Do(api)
 }
@@ -394,7 +394,7 @@ func (api *API) GiftPremiumSubscription(params GiftPremiumSubscriptionP) (bool,
 // GiftPremiumSubscriptionWithContext is the context-aware variant of GiftPremiumSubscription.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#giftpremiumsubscription
-func (api *API) GiftPremiumSubscriptionWithContext(ctx context.Context, params GiftPremiumSubscriptionP) (bool, error) {
+func (api *API) GiftPremiumSubscriptionWithContext(ctx context.Context, params GiftPremiumSubscription) (bool, error) {
 	req := NewRequest[bool]("giftPremiumSubscription", params)
 	return req.DoWithContext(ctx, api)
 }

tgapi/business_methods.go

@@ -2,9 +2,9 @@ package tgapi
 
 import "context"
 
-// VerifyUserP holds parameters for the verifyUser method.
+// VerifyUser holds parameters for the verifyUser method.
 // See https://core.telegram.org/bots/api#verifyuser
-type VerifyUserP struct {
+type VerifyUser struct {
 	UserID            int64  `json:"user_id"`
 	CustomDescription string `json:"custom_description,omitempty"`
 }
@@ -12,7 +12,7 @@ type VerifyUserP struct {
 // VerifyUser verifies a user.
 // Returns true on success.
 // See https://core.telegram.org/bots/api#verifyuser
-func (api *API) VerifyUser(params VerifyUserP) (bool, error) {
+func (api *API) VerifyUser(params VerifyUser) (bool, error) {
 	req := NewRequest[bool]("verifyUser", params)
 	return req.Do(api)
 }
@@ -20,14 +20,14 @@ func (api *API) VerifyUser(params VerifyUserP) (bool, error) {
 // VerifyUserWithContext is the context-aware variant of VerifyUser.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#verifyuser
-func (api *API) VerifyUserWithContext(ctx context.Context, params VerifyUserP) (bool, error) {
+func (api *API) VerifyUserWithContext(ctx context.Context, params VerifyUser) (bool, error) {
 	req := NewRequest[bool]("verifyUser", params)
 	return req.DoWithContext(ctx, api)
 }
 
-// VerifyChatP holds parameters for the verifyChat method.
+// VerifyChat holds parameters for the verifyChat method.
 // See https://core.telegram.org/bots/api#verifychat
-type VerifyChatP struct {
+type VerifyChat struct {
 	ChatID            int64  `json:"chat_id"`
 	CustomDescription string `json:"custom_description,omitempty"`
 }
@@ -35,7 +35,7 @@ type VerifyChatP struct {
 // VerifyChat verifies a chat.
 // Returns true on success.
 // See https://core.telegram.org/bots/api#verifychat
-func (api *API) VerifyChat(params VerifyChatP) (bool, error) {
+func (api *API) VerifyChat(params VerifyChat) (bool, error) {
 	req := NewRequest[bool]("verifyChat", params)
 	return req.Do(api)
 }
@@ -43,21 +43,21 @@ func (api *API) VerifyChat(params VerifyChatP) (bool, error) {
 // VerifyChatWithContext is the context-aware variant of VerifyChat.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#verifychat
-func (api *API) VerifyChatWithContext(ctx context.Context, params VerifyChatP) (bool, error) {
+func (api *API) VerifyChatWithContext(ctx context.Context, params VerifyChat) (bool, error) {
 	req := NewRequest[bool]("verifyChat", params)
 	return req.DoWithContext(ctx, api)
 }
 
-// RemoveUserVerificationP holds parameters for the removeUserVerification method.
+// RemoveUserVerification holds parameters for the removeUserVerification method.
 // See https://core.telegram.org/bots/api#removeuserverification
-type RemoveUserVerificationP struct {
+type RemoveUserVerification struct {
 	UserID int64 `json:"user_id"`
 }
 
 // RemoveUserVerification removes a user's verification.
 // Returns true on success.
 // See https://core.telegram.org/bots/api#removeuserverification
-func (api *API) RemoveUserVerification(params RemoveUserVerificationP) (bool, error) {
+func (api *API) RemoveUserVerification(params RemoveUserVerification) (bool, error) {
 	req := NewRequest[bool]("removeUserVerification", params)
 	return req.Do(api)
 }
@@ -65,21 +65,21 @@ func (api *API) RemoveUserVerification(params RemoveUserVerificationP) (bool, er
 // RemoveUserVerificationWithContext is the context-aware variant of RemoveUserVerification.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#removeuserverification
-func (api *API) RemoveUserVerificationWithContext(ctx context.Context, params RemoveUserVerificationP) (bool, error) {
+func (api *API) RemoveUserVerificationWithContext(ctx context.Context, params RemoveUserVerification) (bool, error) {
 	req := NewRequest[bool]("removeUserVerification", params)
 	return req.DoWithContext(ctx, api)
 }
 
-// RemoveChatVerificationP holds parameters for the removeChatVerification method.
+// RemoveChatVerification holds parameters for the removeChatVerification method.
 // See https://core.telegram.org/bots/api#removechatverification
-type RemoveChatVerificationP struct {
+type RemoveChatVerification struct {
 	ChatID int64 `json:"chat_id"`
 }
 
 // RemoveChatVerification removes a chat's verification.
 // Returns true on success.
 // See https://core.telegram.org/bots/api#removechatverification
-func (api *API) RemoveChatVerification(params RemoveChatVerificationP) (bool, error) {
+func (api *API) RemoveChatVerification(params RemoveChatVerification) (bool, error) {
 	req := NewRequest[bool]("removeChatVerification", params)
 	return req.Do(api)
 }
@@ -87,14 +87,14 @@ func (api *API) RemoveChatVerification(params RemoveChatVerificationP) (bool, er
 // RemoveChatVerificationWithContext is the context-aware variant of RemoveChatVerification.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#removechatverification
-func (api *API) RemoveChatVerificationWithContext(ctx context.Context, params RemoveChatVerificationP) (bool, error) {
+func (api *API) RemoveChatVerificationWithContext(ctx context.Context, params RemoveChatVerification) (bool, error) {
 	req := NewRequest[bool]("removeChatVerification", params)
 	return req.DoWithContext(ctx, api)
 }
 
-// ReadBusinessMessageP holds parameters for the readBusinessMessage method.
+// ReadBusinessMessage holds parameters for the readBusinessMessage method.
 // See https://core.telegram.org/bots/api#readbusinessmessage
-type ReadBusinessMessageP struct {
+type ReadBusinessMessage struct {
 	BusinessConnectionID string `json:"business_connection_id"`
 	ChatID               int64  `json:"chat_id"`
 	MessageID            int    `json:"message_id"`
@@ -103,7 +103,7 @@ type ReadBusinessMessageP struct {
 // ReadBusinessMessage marks a business message as read.
 // Returns true on success.
 // See https://core.telegram.org/bots/api#readbusinessmessage
-func (api *API) ReadBusinessMessage(params ReadBusinessMessageP) (bool, error) {
+func (api *API) ReadBusinessMessage(params ReadBusinessMessage) (bool, error) {
 	req := NewRequest[bool]("readBusinessMessage", params)
 	return req.Do(api)
 }
@@ -111,20 +111,20 @@ func (api *API) ReadBusinessMessage(params ReadBusinessMessageP) (bool, error) {
 // ReadBusinessMessageWithContext is the context-aware variant of ReadBusinessMessage.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#readbusinessmessage
-func (api *API) ReadBusinessMessageWithContext(ctx context.Context, params ReadBusinessMessageP) (bool, error) {
+func (api *API) ReadBusinessMessageWithContext(ctx context.Context, params ReadBusinessMessage) (bool, error) {
 	req := NewRequest[bool]("readBusinessMessage", params)
 	return req.DoWithContext(ctx, api)
 }
 
-// GetBusinessConnectionP holds parameters for the getBusinessConnection method.
+// GetBusinessConnection holds parameters for the getBusinessConnection method.
 // See https://core.telegram.org/bots/api#getbusinessconnection
-type GetBusinessConnectionP struct {
+type GetBusinessConnection struct {
 	BusinessConnectionID string `json:"business_connection_id"`
 }
 
 // GetBusinessConnection returns information about a business connection.
 // See https://core.telegram.org/bots/api#getbusinessconnection
-func (api *API) GetBusinessConnection(params GetBusinessConnectionP) (BusinessConnection, error) {
+func (api *API) GetBusinessConnection(params GetBusinessConnection) (BusinessConnection, error) {
 	req := NewRequest[BusinessConnection]("getBusinessConnection", params)
 	return req.Do(api)
 }
@@ -132,14 +132,14 @@ func (api *API) GetBusinessConnection(params GetBusinessConnectionP) (BusinessCo
 // GetBusinessConnectionWithContext is the context-aware variant of GetBusinessConnection.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#getbusinessconnection
-func (api *API) GetBusinessConnectionWithContext(ctx context.Context, params GetBusinessConnectionP) (BusinessConnection, error) {
+func (api *API) GetBusinessConnectionWithContext(ctx context.Context, params GetBusinessConnection) (BusinessConnection, error) {
 	req := NewRequest[BusinessConnection]("getBusinessConnection", params)
 	return req.DoWithContext(ctx, api)
 }
 
-// DeleteBusinessMessagesP holds parameters for the deleteBusinessMessages method.
+// DeleteBusinessMessages holds parameters for the deleteBusinessMessages method.
 // See https://core.telegram.org/bots/api#deletebusinessmessages
-type DeleteBusinessMessagesP struct {
+type DeleteBusinessMessages struct {
 	BusinessConnectionID string `json:"business_connection_id"`
 	MessageIDs           []int  `json:"message_ids"`
 }
@@ -147,7 +147,7 @@ type DeleteBusinessMessagesP struct {
 // DeleteBusinessMessages deletes business messages.
 // Returns true on success.
 // See https://core.telegram.org/bots/api#deletebusinessmessages
-func (api *API) DeleteBusinessMessages(params DeleteBusinessMessagesP) (bool, error) {
+func (api *API) DeleteBusinessMessages(params DeleteBusinessMessages) (bool, error) {
 	req := NewRequest[bool]("deleteBusinessMessages", params)
 	return req.Do(api)
 }
@@ -155,14 +155,14 @@ func (api *API) DeleteBusinessMessages(params DeleteBusinessMessagesP) (bool, er
 // DeleteBusinessMessagesWithContext is the context-aware variant of DeleteBusinessMessages.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#deletebusinessmessages
-func (api *API) DeleteBusinessMessagesWithContext(ctx context.Context, params DeleteBusinessMessagesP) (bool, error) {
+func (api *API) DeleteBusinessMessagesWithContext(ctx context.Context, params DeleteBusinessMessages) (bool, error) {
 	req := NewRequest[bool]("deleteBusinessMessages", params)
 	return req.DoWithContext(ctx, api)
 }
 
-// SetBusinessAccountNameP holds parameters for the setBusinessAccountName method.
+// SetBusinessAccountName holds parameters for the setBusinessAccountName method.
 // See https://core.telegram.org/bots/api#setbusinessaccountname
-type SetBusinessAccountNameP struct {
+type SetBusinessAccountName struct {
 	BusinessConnectionID string `json:"business_connection_id"`
 	FirstName            string `json:"first_name"`
 	LastName             string `json:"last_name,omitempty"`
@@ -171,7 +171,7 @@ type SetBusinessAccountNameP struct {
 // SetBusinessAccountName sets the first and last name of a business account.
 // Returns true on success.
 // See https://core.telegram.org/bots/api#setbusinessaccountname
-func (api *API) SetBusinessAccountName(params SetBusinessAccountNameP) (bool, error) {
+func (api *API) SetBusinessAccountName(params SetBusinessAccountName) (bool, error) {
 	req := NewRequest[bool]("setBusinessAccountName", params)
 	return req.Do(api)
 }
@@ -179,14 +179,14 @@ func (api *API) SetBusinessAccountName(params SetBusinessAccountNameP) (bool, er
 // SetBusinessAccountNameWithContext is the context-aware variant of SetBusinessAccountName.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#setbusinessaccountname
-func (api *API) SetBusinessAccountNameWithContext(ctx context.Context, params SetBusinessAccountNameP) (bool, error) {
+func (api *API) SetBusinessAccountNameWithContext(ctx context.Context, params SetBusinessAccountName) (bool, error) {
 	req := NewRequest[bool]("setBusinessAccountName", params)
 	return req.DoWithContext(ctx, api)
 }
 
-// SetBusinessAccountUsernameP holds parameters for the setBusinessAccountUsername method.
+// SetBusinessAccountUsername holds parameters for the setBusinessAccountUsername method.
 // See https://core.telegram.org/bots/api#setbusinessaccountusername
-type SetBusinessAccountUsernameP struct {
+type SetBusinessAccountUsername struct {
 	BusinessConnectionID string `json:"business_connection_id"`
 	Username             string `json:"username,omitempty"`
 }
@@ -194,7 +194,7 @@ type SetBusinessAccountUsernameP struct {
 // SetBusinessAccountUsername sets the username of a business account.
 // Returns true on success.
 // See https://core.telegram.org/bots/api#setbusinessaccountusername
-func (api *API) SetBusinessAccountUsername(params SetBusinessAccountUsernameP) (bool, error) {
+func (api *API) SetBusinessAccountUsername(params SetBusinessAccountUsername) (bool, error) {
 	req := NewRequest[bool]("setBusinessAccountUsername", params)
 	return req.Do(api)
 }
@@ -202,14 +202,14 @@ func (api *API) SetBusinessAccountUsername(params SetBusinessAccountUsernameP) (
 // SetBusinessAccountUsernameWithContext is the context-aware variant of SetBusinessAccountUsername.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#setbusinessaccountusername
-func (api *API) SetBusinessAccountUsernameWithContext(ctx context.Context, params SetBusinessAccountUsernameP) (bool, error) {
+func (api *API) SetBusinessAccountUsernameWithContext(ctx context.Context, params SetBusinessAccountUsername) (bool, error) {
 	req := NewRequest[bool]("setBusinessAccountUsername", params)
 	return req.DoWithContext(ctx, api)
 }
 
-// SetBusinessAccountBioP holds parameters for the setBusinessAccountBio method.
+// SetBusinessAccountBio holds parameters for the setBusinessAccountBio method.
 // See https://core.telegram.org/bots/api#setbusinessaccountbio
-type SetBusinessAccountBioP struct {
+type SetBusinessAccountBio struct {
 	BusinessConnectionID string `json:"business_connection_id"`
 	Bio                  string `json:"bio,omitempty"`
 }
@@ -217,7 +217,7 @@ type SetBusinessAccountBioP struct {
 // SetBusinessAccountBio sets the bio of a business account.
 // Returns true on success.
 // See https://core.telegram.org/bots/api#setbusinessaccountbio
-func (api *API) SetBusinessAccountBio(params SetBusinessAccountBioP) (bool, error) {
+func (api *API) SetBusinessAccountBio(params SetBusinessAccountBio) (bool, error) {
 	req := NewRequest[bool]("setBusinessAccountBio", params)
 	return req.Do(api)
 }
@@ -225,7 +225,7 @@ func (api *API) SetBusinessAccountBio(params SetBusinessAccountBioP) (bool, erro
 // SetBusinessAccountBioWithContext is the context-aware variant of SetBusinessAccountBio.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#setbusinessaccountbio
-func (api *API) SetBusinessAccountBioWithContext(ctx context.Context, params SetBusinessAccountBioP) (bool, error) {
+func (api *API) SetBusinessAccountBioWithContext(ctx context.Context, params SetBusinessAccountBio) (bool, error) {
 	req := NewRequest[bool]("setBusinessAccountBio", params)
 	return req.DoWithContext(ctx, api)
 }
@@ -254,9 +254,9 @@ func (api *API) SetBusinessAccountProfilePhotoWithContext(ctx context.Context, p
 	return req.DoWithContext(ctx, api)
 }
 
-// RemoveBusinessAccountProfilePhotoP holds parameters for the removeBusinessAccountProfilePhoto method.
+// RemoveBusinessAccountProfilePhoto holds parameters for the removeBusinessAccountProfilePhoto method.
 // See https://core.telegram.org/bots/api#removebusinessaccountprofilephoto
-type RemoveBusinessAccountProfilePhotoP struct {
+type RemoveBusinessAccountProfilePhoto struct {
 	BusinessConnectionID string `json:"business_connection_id"`
 	IsPublic             bool   `json:"is_public,omitempty"`
 }
@@ -264,7 +264,7 @@ type RemoveBusinessAccountProfilePhotoP struct {
 // RemoveBusinessAccountProfilePhoto removes the profile photo of a business account.
 // Returns true on success.
 // See https://core.telegram.org/bots/api#removebusinessaccountprofilephoto
-func (api *API) RemoveBusinessAccountProfilePhoto(params RemoveBusinessAccountProfilePhotoP) (bool, error) {
+func (api *API) RemoveBusinessAccountProfilePhoto(params RemoveBusinessAccountProfilePhoto) (bool, error) {
 	req := NewRequest[bool]("removeBusinessAccountProfilePhoto", params)
 	return req.Do(api)
 }
@@ -272,14 +272,14 @@ func (api *API) RemoveBusinessAccountProfilePhoto(params RemoveBusinessAccountPr
 // RemoveBusinessAccountProfilePhotoWithContext is the context-aware variant of RemoveBusinessAccountProfilePhoto.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#removebusinessaccountprofilephoto
-func (api *API) RemoveBusinessAccountProfilePhotoWithContext(ctx context.Context, params RemoveBusinessAccountProfilePhotoP) (bool, error) {
+func (api *API) RemoveBusinessAccountProfilePhotoWithContext(ctx context.Context, params RemoveBusinessAccountProfilePhoto) (bool, error) {
 	req := NewRequest[bool]("removeBusinessAccountProfilePhoto", params)
 	return req.DoWithContext(ctx, api)
 }
 
-// SetBusinessAccountGiftSettingsP holds parameters for the setBusinessAccountGiftSettings method.
+// SetBusinessAccountGiftSettings holds parameters for the setBusinessAccountGiftSettings method.
 // See https://core.telegram.org/bots/api#setbusinessaccountgiftsettings
-type SetBusinessAccountGiftSettingsP struct {
+type SetBusinessAccountGiftSettings struct {
 	BusinessConnectionID string            `json:"business_connection_id"`
 	ShowGiftButton       bool              `json:"show_gift_button"`
 	AcceptedGiftTypes    AcceptedGiftTypes `json:"accepted_gift_types"`
@@ -288,7 +288,7 @@ type SetBusinessAccountGiftSettingsP struct {
 // SetBusinessAccountGiftSettings sets gift settings for a business account.
 // Returns true on success.
 // See https://core.telegram.org/bots/api#setbusinessaccountgiftsettings
-func (api *API) SetBusinessAccountGiftSettings(params SetBusinessAccountGiftSettingsP) (bool, error) {
+func (api *API) SetBusinessAccountGiftSettings(params SetBusinessAccountGiftSettings) (bool, error) {
 	req := NewRequest[bool]("setBusinessAccountGiftSettings", params)
 	return req.Do(api)
 }
@@ -296,20 +296,20 @@ func (api *API) SetBusinessAccountGiftSettings(params SetBusinessAccountGiftSett
 // SetBusinessAccountGiftSettingsWithContext is the context-aware variant of SetBusinessAccountGiftSettings.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#setbusinessaccountgiftsettings
-func (api *API) SetBusinessAccountGiftSettingsWithContext(ctx context.Context, params SetBusinessAccountGiftSettingsP) (bool, error) {
+func (api *API) SetBusinessAccountGiftSettingsWithContext(ctx context.Context, params SetBusinessAccountGiftSettings) (bool, error) {
 	req := NewRequest[bool]("setBusinessAccountGiftSettings", params)
 	return req.DoWithContext(ctx, api)
 }
 
-// GetBusinessAccountStarBalanceP holds parameters for the getBusinessAccountStarBalance method.
+// GetBusinessAccountStarBalance holds parameters for the getBusinessAccountStarBalance method.
 // See https://core.telegram.org/bots/api#getbusinessaccountstarbalance
-type GetBusinessAccountStarBalanceP struct {
+type GetBusinessAccountStarBalance struct {
 	BusinessConnectionID string `json:"business_connection_id"`
 }
 
 // GetBusinessAccountStarBalance returns the star balance of a business account.
 // See https://core.telegram.org/bots/api#getbusinessaccountstarbalance
-func (api *API) GetBusinessAccountStarBalance(params GetBusinessAccountStarBalanceP) (StarAmount, error) {
+func (api *API) GetBusinessAccountStarBalance(params GetBusinessAccountStarBalance) (StarAmount, error) {
 	req := NewRequest[StarAmount]("getBusinessAccountStarBalance", params)
 	return req.Do(api)
 }
@@ -317,14 +317,14 @@ func (api *API) GetBusinessAccountStarBalance(params GetBusinessAccountStarBalan
 // GetBusinessAccountStarBalanceWithContext is the context-aware variant of GetBusinessAccountStarBalance.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#getbusinessaccountstarbalance
-func (api *API) GetBusinessAccountStarBalanceWithContext(ctx context.Context, params GetBusinessAccountStarBalanceP) (StarAmount, error) {
+func (api *API) GetBusinessAccountStarBalanceWithContext(ctx context.Context, params GetBusinessAccountStarBalance) (StarAmount, error) {
 	req := NewRequest[StarAmount]("getBusinessAccountStarBalance", params)
 	return req.DoWithContext(ctx, api)
 }
 
-// TransferBusinessAccountStarsP holds parameters for the transferBusinessAccountStars method.
+// TransferBusinessAccountStars holds parameters for the transferBusinessAccountStars method.
 // See https://core.telegram.org/bots/api#transferbusinessaccountstars
-type TransferBusinessAccountStarsP struct {
+type TransferBusinessAccountStars struct {
 	BusinessConnectionID string `json:"business_connection_id"`
 	StarCount            int    `json:"star_count"`
 }
@@ -332,7 +332,7 @@ type TransferBusinessAccountStarsP struct {
 // TransferBusinessAccountStars transfers stars from a business account.
 // Returns true on success.
 // See https://core.telegram.org/bots/api#transferbusinessaccountstars
-func (api *API) TransferBusinessAccountStars(params TransferBusinessAccountStarsP) (bool, error) {
+func (api *API) TransferBusinessAccountStars(params TransferBusinessAccountStars) (bool, error) {
 	req := NewRequest[bool]("transferBusinessAccountStars", params)
 	return req.Do(api)
 }
@@ -340,14 +340,14 @@ func (api *API) TransferBusinessAccountStars(params TransferBusinessAccountStars
 // TransferBusinessAccountStarsWithContext is the context-aware variant of TransferBusinessAccountStars.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#transferbusinessaccountstars
-func (api *API) TransferBusinessAccountStarsWithContext(ctx context.Context, params TransferBusinessAccountStarsP) (bool, error) {
+func (api *API) TransferBusinessAccountStarsWithContext(ctx context.Context, params TransferBusinessAccountStars) (bool, error) {
 	req := NewRequest[bool]("transferBusinessAccountStars", params)
 	return req.DoWithContext(ctx, api)
 }
 
-// GetBusinessAccountGiftsP holds parameters for the getBusinessAccountGifts method.
+// GetBusinessAccountGifts holds parameters for the getBusinessAccountGifts method.
 // See https://core.telegram.org/bots/api#getbusinessaccountgifts
-type GetBusinessAccountGiftsP struct {
+type GetBusinessAccountGifts struct {
 	BusinessConnectionID        string `json:"business_connection_id"`
 	ExcludeUnsaved              bool   `json:"exclude_unsaved,omitempty"`
 	ExcludeSaved                bool   `json:"exclude_saved,omitempty"`
@@ -363,7 +363,7 @@ type GetBusinessAccountGiftsP struct {
 
 // GetBusinessAccountGifts returns gifts owned by a business account.
 // See https://core.telegram.org/bots/api#getbusinessaccountgifts
-func (api *API) GetBusinessAccountGifts(params GetBusinessAccountGiftsP) (OwnedGifts, error) {
+func (api *API) GetBusinessAccountGifts(params GetBusinessAccountGifts) (OwnedGifts, error) {
 	req := NewRequest[OwnedGifts]("getBusinessAccountGifts", params)
 	return req.Do(api)
 }
@@ -371,14 +371,14 @@ func (api *API) GetBusinessAccountGifts(params GetBusinessAccountGiftsP) (OwnedG
 // GetBusinessAccountGiftsWithContext is the context-aware variant of GetBusinessAccountGifts.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#getbusinessaccountgifts
-func (api *API) GetBusinessAccountGiftsWithContext(ctx context.Context, params GetBusinessAccountGiftsP) (OwnedGifts, error) {
+func (api *API) GetBusinessAccountGiftsWithContext(ctx context.Context, params GetBusinessAccountGifts) (OwnedGifts, error) {
 	req := NewRequest[OwnedGifts]("getBusinessAccountGifts", params)
 	return req.DoWithContext(ctx, api)
 }
 
-// ConvertGiftToStarsP holds parameters for the convertGiftToStars method.
+// ConvertGiftToStars holds parameters for the convertGiftToStars method.
 // See https://core.telegram.org/bots/api#convertgifttostars
-type ConvertGiftToStarsP struct {
+type ConvertGiftToStars struct {
 	BusinessConnectionID string `json:"business_connection_id"`
 	OwnedGiftID          string `json:"owned_gift_id"`
 }
@@ -386,7 +386,7 @@ type ConvertGiftToStarsP struct {
 // ConvertGiftToStars converts a gift to Telegram Stars.
 // Returns true on success.
 // See https://core.telegram.org/bots/api#convertgifttostars
-func (api *API) ConvertGiftToStars(params ConvertGiftToStarsP) (bool, error) {
+func (api *API) ConvertGiftToStars(params ConvertGiftToStars) (bool, error) {
 	req := NewRequest[bool]("convertGiftToStars", params)
 	return req.Do(api)
 }
@@ -394,14 +394,14 @@ func (api *API) ConvertGiftToStars(params ConvertGiftToStarsP) (bool, error) {
 // ConvertGiftToStarsWithContext is the context-aware variant of ConvertGiftToStars.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#convertgifttostars
-func (api *API) ConvertGiftToStarsWithContext(ctx context.Context, params ConvertGiftToStarsP) (bool, error) {
+func (api *API) ConvertGiftToStarsWithContext(ctx context.Context, params ConvertGiftToStars) (bool, error) {
 	req := NewRequest[bool]("convertGiftToStars", params)
 	return req.DoWithContext(ctx, api)
 }
 
-// UpgradeGiftP holds parameters for the upgradeGift method.
+// UpgradeGift holds parameters for the upgradeGift method.
 // See https://core.telegram.org/bots/api#upgradegift
-type UpgradeGiftP struct {
+type UpgradeGift struct {
 	BusinessConnectionID string `json:"business_connection_id"`
 	OwnedGiftID          string `json:"owned_gift_id"`
 	KeepOriginalDetails  bool   `json:"keep_original_details,omitempty"`
@@ -411,7 +411,7 @@ type UpgradeGiftP struct {
 // UpgradeGift upgrades a gift.
 // Returns true on success.
 // See https://core.telegram.org/bots/api#upgradegift
-func (api *API) UpgradeGift(params UpgradeGiftP) (bool, error) {
+func (api *API) UpgradeGift(params UpgradeGift) (bool, error) {
 	req := NewRequest[bool]("upgradeGift", params)
 	return req.Do(api)
 }
@@ -419,14 +419,14 @@ func (api *API) UpgradeGift(params UpgradeGiftP) (bool, error) {
 // UpgradeGiftWithContext is the context-aware variant of UpgradeGift.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#upgradegift
-func (api *API) UpgradeGiftWithContext(ctx context.Context, params UpgradeGiftP) (bool, error) {
+func (api *API) UpgradeGiftWithContext(ctx context.Context, params UpgradeGift) (bool, error) {
 	req := NewRequest[bool]("upgradeGift", params)
 	return req.DoWithContext(ctx, api)
 }
 
-// TransferGiftP holds parameters for the transferGift method.
+// TransferGift holds parameters for the transferGift method.
 // See https://core.telegram.org/bots/api#transfergift
-type TransferGiftP struct {
+type TransferGift struct {
 	BusinessConnectionID string `json:"business_connection_id"`
 	OwnedGiftID          string `json:"owned_gift_id"`
 	NewOwnerChatID       int64  `json:"new_owner_chat_id"`
@@ -436,7 +436,7 @@ type TransferGiftP struct {
 // TransferGift transfers a gift to another chat.
 // Returns true on success.
 // See https://core.telegram.org/bots/api#transfergift
-func (api *API) TransferGift(params TransferGiftP) (bool, error) {
+func (api *API) TransferGift(params TransferGift) (bool, error) {
 	req := NewRequest[bool]("transferGift", params)
 	return req.Do(api)
 }
@@ -444,14 +444,14 @@ func (api *API) TransferGift(params TransferGiftP) (bool, error) {
 // TransferGiftWithContext is the context-aware variant of TransferGift.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#transfergift
-func (api *API) TransferGiftWithContext(ctx context.Context, params TransferGiftP) (bool, error) {
+func (api *API) TransferGiftWithContext(ctx context.Context, params TransferGift) (bool, error) {
 	req := NewRequest[bool]("transferGift", params)
 	return req.DoWithContext(ctx, api)
 }
 
-// PostStoryP holds parameters for the postStory method.
+// PostStory holds parameters for the postStory method.
 // See https://core.telegram.org/bots/api#poststory
-type PostStoryP struct {
+type PostStory struct {
 	BusinessConnectionID string            `json:"business_connection_id"`
 	Content              InputStoryContent `json:"content"`
 	ActivePeriod         int               `json:"active_period"`
@@ -465,39 +465,24 @@ type PostStoryP struct {
 	ProtectContent bool `json:"protect_content,omitempty"`
 }
 
-// PostStoryPhoto posts a story with a photo.
+// PostStory posts a story with a photo.
 // See https://core.telegram.org/bots/api#poststory
-func (api *API) PostStoryPhoto(params PostStoryP) (Story, error) {
+func (api *API) PostStory(params PostStory) (Story, error) {
 	req := NewRequest[Story]("postStory", params)
 	return req.Do(api)
 }
 
-// PostStoryPhotoWithContext is the context-aware variant of PostStoryPhoto.
+// PostStoryWithContext is the context-aware variant of PostStoryPhoto.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#poststory
-func (api *API) PostStoryPhotoWithContext(ctx context.Context, params PostStoryP) (Story, error) {
+func (api *API) PostStoryWithContext(ctx context.Context, params PostStory) (Story, error) {
 	req := NewRequest[Story]("postStory", params)
 	return req.DoWithContext(ctx, api)
 }
 
-// PostStoryVideo posts a story with a video.
-// See https://core.telegram.org/bots/api#poststory
-func (api *API) PostStoryVideo(params PostStoryP) (Story, error) {
-	req := NewRequest[Story]("postStory", params)
-	return req.Do(api)
-}
-
-// PostStoryVideoWithContext is the context-aware variant of PostStoryVideo.
-// It executes the same request but uses ctx for cancellation and deadlines.
-// See https://core.telegram.org/bots/api#poststory
-func (api *API) PostStoryVideoWithContext(ctx context.Context, params PostStoryP) (Story, error) {
-	req := NewRequest[Story]("postStory", params)
-	return req.DoWithContext(ctx, api)
-}
-
-// RepostStoryP holds parameters for the repostStory method.
+// RepostStory holds parameters for the repostStory method.
 // See https://core.telegram.org/bots/api#repoststory
-type RepostStoryP struct {
+type RepostStory struct {
 	BusinessConnectionID string `json:"business_connection_id"`
 	FromChatID           int64  `json:"from_chat_id"`
 	FromStoryID          int    `json:"from_story_id"`
@@ -509,7 +494,7 @@ type RepostStoryP struct {
 // RepostStory reposts a story from another chat.
 // Returns the reposted story.
 // See https://core.telegram.org/bots/api#repoststory
-func (api *API) RepostStory(params RepostStoryP) (Story, error) {
+func (api *API) RepostStory(params RepostStory) (Story, error) {
 	req := NewRequest[Story]("repostStory", params)
 	return req.Do(api)
 }
@@ -517,14 +502,14 @@ func (api *API) RepostStory(params RepostStoryP) (Story, error) {
 // RepostStoryWithContext is the context-aware variant of RepostStory.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#repoststory
-func (api *API) RepostStoryWithContext(ctx context.Context, params RepostStoryP) (Story, error) {
+func (api *API) RepostStoryWithContext(ctx context.Context, params RepostStory) (Story, error) {
 	req := NewRequest[Story]("repostStory", params)
 	return req.DoWithContext(ctx, api)
 }
 
-// EditStoryP holds parameters for the editStory method.
+// EditStory holds parameters for the editStory method.
 // See https://core.telegram.org/bots/api#editstory
-type EditStoryP struct {
+type EditStory struct {
 	BusinessConnectionID string            `json:"business_connection_id"`
 	StoryID              int               `json:"story_id"`
 	Content              InputStoryContent `json:"content"`
@@ -538,7 +523,7 @@ type EditStoryP struct {
 // EditStory edits an existing story.
 // Returns the updated story.
 // See https://core.telegram.org/bots/api#editstory
-func (api *API) EditStory(params EditStoryP) (Story, error) {
+func (api *API) EditStory(params EditStory) (Story, error) {
 	req := NewRequest[Story]("editStory", params)
 	return req.Do(api)
 }
@@ -546,14 +531,14 @@ func (api *API) EditStory(params EditStoryP) (Story, error) {
 // EditStoryWithContext is the context-aware variant of EditStory.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#editstory
-func (api *API) EditStoryWithContext(ctx context.Context, params EditStoryP) (Story, error) {
+func (api *API) EditStoryWithContext(ctx context.Context, params EditStory) (Story, error) {
 	req := NewRequest[Story]("editStory", params)
 	return req.DoWithContext(ctx, api)
 }
 
-// DeleteStoryP holds parameters for the deleteStory method.
+// DeleteStory holds parameters for the deleteStory method.
 // See https://core.telegram.org/bots/api#deletestory
-type DeleteStoryP struct {
+type DeleteStory struct {
 	BusinessConnectionID string `json:"business_connection_id"`
 	StoryID              int    `json:"story_id"`
 }
@@ -561,7 +546,7 @@ type DeleteStoryP struct {
 // DeleteStory deletes a story.
 // Returns true on success.
 // See https://core.telegram.org/bots/api#deletestory
-func (api *API) DeleteStory(params DeleteStoryP) (bool, error) {
+func (api *API) DeleteStory(params DeleteStory) (bool, error) {
 	req := NewRequest[bool]("deleteStory", params)
 	return req.Do(api)
 }
@@ -569,7 +554,7 @@ func (api *API) DeleteStory(params DeleteStoryP) (bool, error) {
 // DeleteStoryWithContext is the context-aware variant of DeleteStory.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#deletestory
-func (api *API) DeleteStoryWithContext(ctx context.Context, params DeleteStoryP) (bool, error) {
+func (api *API) DeleteStoryWithContext(ctx context.Context, params DeleteStory) (bool, error) {
 	req := NewRequest[bool]("deleteStory", params)
 	return req.DoWithContext(ctx, api)
 }

tgapi/chat_methods.go

@@ -2,9 +2,9 @@ package tgapi
 
 import "context"
 
-// BanChatMemberP holds parameters for the banChatMember method.
+// BanChatMember holds parameters for the banChatMember method.
 // See https://core.telegram.org/bots/api#banchatmember
-type BanChatMemberP struct {
+type BanChatMember struct {
 	ChatID         int64 `json:"chat_id"`
 	UserID         int64 `json:"user_id"`
 	UntilDate      int   `json:"until_date,omitempty"`
@@ -14,7 +14,7 @@ type BanChatMemberP struct {
 // BanChatMember bans a user in a chat.
 // Returns True on success.
 // See https://core.telegram.org/bots/api#banchatmember
-func (api *API) BanChatMember(params BanChatMemberP) (bool, error) {
+func (api *API) BanChatMember(params BanChatMember) (bool, error) {
 	req := NewRequestWithChatID[bool]("banChatMember", params, params.ChatID)
 	return req.Do(api)
 }
@@ -22,14 +22,14 @@ func (api *API) BanChatMember(params BanChatMemberP) (bool, error) {
 // BanChatMemberWithContext is the context-aware variant of BanChatMember.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#banchatmember
-func (api *API) BanChatMemberWithContext(ctx context.Context, params BanChatMemberP) (bool, error) {
+func (api *API) BanChatMemberWithContext(ctx context.Context, params BanChatMember) (bool, error) {
 	req := NewRequestWithChatID[bool]("banChatMember", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
 
-// UnbanChatMemberP holds parameters for the unbanChatMember method.
+// UnbanChatMember holds parameters for the unbanChatMember method.
 // See https://core.telegram.org/bots/api#unbanchatmember
-type UnbanChatMemberP struct {
+type UnbanChatMember struct {
 	ChatID       int64 `json:"chat_id"`
 	UserID       int64 `json:"user_id"`
 	OnlyIfBanned bool  `json:"only_if_banned"`
@@ -38,7 +38,7 @@ type UnbanChatMemberP struct {
 // UnbanChatMember unbans a previously banned user in a chat.
 // Returns True on success.
 // See https://core.telegram.org/bots/api#unbanchatmember
-func (api *API) UnbanChatMember(params UnbanChatMemberP) (bool, error) {
+func (api *API) UnbanChatMember(params UnbanChatMember) (bool, error) {
 	req := NewRequestWithChatID[bool]("unbanChatMember", params, params.ChatID)
 	return req.Do(api)
 }
@@ -46,14 +46,14 @@ func (api *API) UnbanChatMember(params UnbanChatMemberP) (bool, error) {
 // UnbanChatMemberWithContext is the context-aware variant of UnbanChatMember.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#unbanchatmember
-func (api *API) UnbanChatMemberWithContext(ctx context.Context, params UnbanChatMemberP) (bool, error) {
+func (api *API) UnbanChatMemberWithContext(ctx context.Context, params UnbanChatMember) (bool, error) {
 	req := NewRequestWithChatID[bool]("unbanChatMember", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
 
-// RestrictChatMemberP holds parameters for the restrictChatMember method.
+// RestrictChatMember holds parameters for the restrictChatMember method.
 // See https://core.telegram.org/bots/api#restrictchatmember
-type RestrictChatMemberP struct {
+type RestrictChatMember struct {
 	ChatID                        int64           `json:"chat_id"`
 	UserID                        int64           `json:"user_id"`
 	Permissions                   ChatPermissions `json:"permissions"`
@@ -64,7 +64,7 @@ type RestrictChatMemberP struct {
 // RestrictChatMember restricts a user in a chat.
 // Returns True on success.
 // See https://core.telegram.org/bots/api#restrictchatmember
-func (api *API) RestrictChatMember(params RestrictChatMemberP) (bool, error) {
+func (api *API) RestrictChatMember(params RestrictChatMember) (bool, error) {
 	req := NewRequestWithChatID[bool]("restrictChatMember", params, params.ChatID)
 	return req.Do(api)
 }
@@ -72,7 +72,7 @@ func (api *API) RestrictChatMember(params RestrictChatMemberP) (bool, error) {
 // RestrictChatMemberWithContext is the context-aware variant of RestrictChatMember.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#restrictchatmember
-func (api *API) RestrictChatMemberWithContext(ctx context.Context, params RestrictChatMemberP) (bool, error) {
+func (api *API) RestrictChatMemberWithContext(ctx context.Context, params RestrictChatMember) (bool, error) {
 	req := NewRequestWithChatID[bool]("restrictChatMember", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
@@ -118,9 +118,9 @@ func (api *API) PromoteChatMemberWithContext(ctx context.Context, params Promote
 	return req.DoWithContext(ctx, api)
 }
 
-// SetChatAdministratorCustomTitleP holds parameters for the setChatAdministratorCustomTitle method.
+// SetChatAdministratorCustomTitle holds parameters for the setChatAdministratorCustomTitle method.
 // See https://core.telegram.org/bots/api#setchatadministratorcustomtitle
-type SetChatAdministratorCustomTitleP struct {
+type SetChatAdministratorCustomTitle struct {
 	ChatID      int64  `json:"chat_id"`
 	UserID      int64  `json:"user_id"`
 	CustomTitle string `json:"custom_title"`
@@ -129,7 +129,7 @@ type SetChatAdministratorCustomTitleP struct {
 // SetChatAdministratorCustomTitle sets a custom title for an administrator.
 // Returns True on success.
 // See https://core.telegram.org/bots/api#setchatadministratorcustomtitle
-func (api *API) SetChatAdministratorCustomTitle(params SetChatAdministratorCustomTitleP) (bool, error) {
+func (api *API) SetChatAdministratorCustomTitle(params SetChatAdministratorCustomTitle) (bool, error) {
 	req := NewRequestWithChatID[bool]("setChatAdministratorCustomTitle", params, params.ChatID)
 	return req.Do(api)
 }
@@ -137,14 +137,14 @@ func (api *API) SetChatAdministratorCustomTitle(params SetChatAdministratorCusto
 // SetChatAdministratorCustomTitleWithContext is the context-aware variant of SetChatAdministratorCustomTitle.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#setchatadministratorcustomtitle
-func (api *API) SetChatAdministratorCustomTitleWithContext(ctx context.Context, params SetChatAdministratorCustomTitleP) (bool, error) {
+func (api *API) SetChatAdministratorCustomTitleWithContext(ctx context.Context, params SetChatAdministratorCustomTitle) (bool, error) {
 	req := NewRequestWithChatID[bool]("setChatAdministratorCustomTitle", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
 
-// SetChatMemberTagP holds parameters for the setChatMemberTag method.
+// SetChatMemberTag holds parameters for the setChatMemberTag method.
 // See https://core.telegram.org/bots/api#setchatmembertag
-type SetChatMemberTagP struct {
+type SetChatMemberTag struct {
 	ChatID int64  `json:"chat_id"`
 	UserID int64  `json:"user_id"`
 	Tag    string `json:"tag,omitempty"`
@@ -153,7 +153,7 @@ type SetChatMemberTagP struct {
 // SetChatMemberTag sets a tag for a chat member.
 // Returns True on success.
 // See https://core.telegram.org/bots/api#setchatmembertag
-func (api *API) SetChatMemberTag(params SetChatMemberTagP) (bool, error) {
+func (api *API) SetChatMemberTag(params SetChatMemberTag) (bool, error) {
 	req := NewRequestWithChatID[bool]("setChatMemberTag", params, params.ChatID)
 	return req.Do(api)
 }
@@ -161,14 +161,14 @@ func (api *API) SetChatMemberTag(params SetChatMemberTagP) (bool, error) {
 // SetChatMemberTagWithContext is the context-aware variant of SetChatMemberTag.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#setchatmembertag
-func (api *API) SetChatMemberTagWithContext(ctx context.Context, params SetChatMemberTagP) (bool, error) {
+func (api *API) SetChatMemberTagWithContext(ctx context.Context, params SetChatMemberTag) (bool, error) {
 	req := NewRequestWithChatID[bool]("setChatMemberTag", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
 
-// BanChatSenderChatP holds parameters for the banChatSenderChat method.
+// BanChatSenderChat holds parameters for the banChatSenderChat method.
 // See https://core.telegram.org/bots/api#banchatsenderchat
-type BanChatSenderChatP struct {
+type BanChatSenderChat struct {
 	ChatID       int64 `json:"chat_id"`
 	SenderChatID int64 `json:"sender_chat_id"`
 }
@@ -176,7 +176,7 @@ type BanChatSenderChatP struct {
 // BanChatSenderChat bans a channel chat in a supergroup or channel.
 // Returns True on success.
 // See https://core.telegram.org/bots/api#banchatsenderchat
-func (api *API) BanChatSenderChat(params BanChatSenderChatP) (bool, error) {
+func (api *API) BanChatSenderChat(params BanChatSenderChat) (bool, error) {
 	req := NewRequestWithChatID[bool]("banChatSenderChat", params, params.ChatID)
 	return req.Do(api)
 }
@@ -184,14 +184,14 @@ func (api *API) BanChatSenderChat(params BanChatSenderChatP) (bool, error) {
 // BanChatSenderChatWithContext is the context-aware variant of BanChatSenderChat.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#banchatsenderchat
-func (api *API) BanChatSenderChatWithContext(ctx context.Context, params BanChatSenderChatP) (bool, error) {
+func (api *API) BanChatSenderChatWithContext(ctx context.Context, params BanChatSenderChat) (bool, error) {
 	req := NewRequestWithChatID[bool]("banChatSenderChat", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
 
-// UnbanChatSenderChatP holds parameters for the unbanChatSenderChat method.
+// UnbanChatSenderChat holds parameters for the unbanChatSenderChat method.
 // See https://core.telegram.org/bots/api#unbanchatsenderchat
-type UnbanChatSenderChatP struct {
+type UnbanChatSenderChat struct {
 	ChatID       int64 `json:"chat_id"`
 	SenderChatID int64 `json:"sender_chat_id"`
 }
@@ -199,7 +199,7 @@ type UnbanChatSenderChatP struct {
 // UnbanChatSenderChat unbans a previously banned channel chat.
 // Returns True on success.
 // See https://core.telegram.org/bots/api#unbanchatsenderchat
-func (api *API) UnbanChatSenderChat(params UnbanChatSenderChatP) (bool, error) {
+func (api *API) UnbanChatSenderChat(params UnbanChatSenderChat) (bool, error) {
 	req := NewRequestWithChatID[bool]("unbanChatSenderChat", params, params.ChatID)
 	return req.Do(api)
 }
@@ -207,14 +207,14 @@ func (api *API) UnbanChatSenderChat(params UnbanChatSenderChatP) (bool, error) {
 // UnbanChatSenderChatWithContext is the context-aware variant of UnbanChatSenderChat.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#unbanchatsenderchat
-func (api *API) UnbanChatSenderChatWithContext(ctx context.Context, params UnbanChatSenderChatP) (bool, error) {
+func (api *API) UnbanChatSenderChatWithContext(ctx context.Context, params UnbanChatSenderChat) (bool, error) {
 	req := NewRequestWithChatID[bool]("unbanChatSenderChat", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
 
-// SetChatPermissionsP holds parameters for the setChatPermissions method.
+// SetChatPermissions holds parameters for the setChatPermissions method.
 // See https://core.telegram.org/bots/api#setchatpermissions
-type SetChatPermissionsP struct {
+type SetChatPermissions struct {
 	ChatID                        int64           `json:"chat_id"`
 	Permissions                   ChatPermissions `json:"permissions"`
 	UseIndependentChatPermissions bool            `json:"use_independent_chat_permissions,omitempty"`
@@ -223,7 +223,7 @@ type SetChatPermissionsP struct {
 // SetChatPermissions sets default chat permissions for all members.
 // Returns True on success.
 // See https://core.telegram.org/bots/api#setchatpermissions
-func (api *API) SetChatPermissions(params SetChatPermissionsP) (bool, error) {
+func (api *API) SetChatPermissions(params SetChatPermissions) (bool, error) {
 	req := NewRequestWithChatID[bool]("setChatPermissions", params, params.ChatID)
 	return req.Do(api)
 }
@@ -231,21 +231,21 @@ func (api *API) SetChatPermissions(params SetChatPermissionsP) (bool, error) {
 // SetChatPermissionsWithContext is the context-aware variant of SetChatPermissions.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#setchatpermissions
-func (api *API) SetChatPermissionsWithContext(ctx context.Context, params SetChatPermissionsP) (bool, error) {
+func (api *API) SetChatPermissionsWithContext(ctx context.Context, params SetChatPermissions) (bool, error) {
 	req := NewRequestWithChatID[bool]("setChatPermissions", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
 
-// ExportChatInviteLinkP holds parameters for the exportChatInviteLink method.
+// ExportChatInviteLink holds parameters for the exportChatInviteLink method.
 // See https://core.telegram.org/bots/api#exportchatinvitelink
-type ExportChatInviteLinkP struct {
+type ExportChatInviteLink struct {
 	ChatID int64 `json:"chat_id"`
 }
 
 // ExportChatInviteLink generates a new primary invite link for a chat.
 // Returns the new invite link as string.
 // See https://core.telegram.org/bots/api#exportchatinvitelink
-func (api *API) ExportChatInviteLink(params ExportChatInviteLinkP) (string, error) {
+func (api *API) ExportChatInviteLink(params ExportChatInviteLink) (string, error) {
 	req := NewRequestWithChatID[string]("exportChatInviteLink", params, params.ChatID)
 	return req.Do(api)
 }
@@ -253,14 +253,14 @@ func (api *API) ExportChatInviteLink(params ExportChatInviteLinkP) (string, erro
 // ExportChatInviteLinkWithContext is the context-aware variant of ExportChatInviteLink.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#exportchatinvitelink
-func (api *API) ExportChatInviteLinkWithContext(ctx context.Context, params ExportChatInviteLinkP) (string, error) {
+func (api *API) ExportChatInviteLinkWithContext(ctx context.Context, params ExportChatInviteLink) (string, error) {
 	req := NewRequestWithChatID[string]("exportChatInviteLink", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
 
-// CreateChatInviteLinkP holds parameters for the createChatInviteLink method.
+// CreateChatInviteLink holds parameters for the createChatInviteLink method.
 // See https://core.telegram.org/bots/api#createchatinvitelink
-type CreateChatInviteLinkP struct {
+type CreateChatInviteLink struct {
 	ChatID             int64   `json:"chat_id"`
 	Name               *string `json:"name,omitempty"`
 	ExpireDate         int     `json:"expire_date,omitempty"`
@@ -271,7 +271,7 @@ type CreateChatInviteLinkP struct {
 // CreateChatInviteLink creates an additional invite link for a chat.
 // Returns the created invite link.
 // See https://core.telegram.org/bots/api#createchatinvitelink
-func (api *API) CreateChatInviteLink(params CreateChatInviteLinkP) (ChatInviteLink, error) {
+func (api *API) CreateChatInviteLink(params CreateChatInviteLink) (ChatInviteLink, error) {
 	req := NewRequestWithChatID[ChatInviteLink]("createChatInviteLink", params, params.ChatID)
 	return req.Do(api)
 }
@@ -279,14 +279,14 @@ func (api *API) CreateChatInviteLink(params CreateChatInviteLinkP) (ChatInviteLi
 // CreateChatInviteLinkWithContext is the context-aware variant of CreateChatInviteLink.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#createchatinvitelink
-func (api *API) CreateChatInviteLinkWithContext(ctx context.Context, params CreateChatInviteLinkP) (ChatInviteLink, error) {
+func (api *API) CreateChatInviteLinkWithContext(ctx context.Context, params CreateChatInviteLink) (ChatInviteLink, error) {
 	req := NewRequestWithChatID[ChatInviteLink]("createChatInviteLink", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
 
-// EditChatInviteLinkP holds parameters for the editChatInviteLink method.
+// EditChatInviteLink holds parameters for the editChatInviteLink method.
 // See https://core.telegram.org/bots/api#editchatinvitelink
-type EditChatInviteLinkP struct {
+type EditChatInviteLink struct {
 	ChatID     int64  `json:"chat_id"`
 	InviteLink string `json:"invite_link"`
 
@@ -299,7 +299,7 @@ type EditChatInviteLinkP struct {
 // EditChatInviteLink edits a non‑primary invite link.
 // Returns the edited invite link.
 // See https://core.telegram.org/bots/api#editchatinvitelink
-func (api *API) EditChatInviteLink(params EditChatInviteLinkP) (ChatInviteLink, error) {
+func (api *API) EditChatInviteLink(params EditChatInviteLink) (ChatInviteLink, error) {
 	req := NewRequestWithChatID[ChatInviteLink]("editChatInviteLink", params, params.ChatID)
 	return req.Do(api)
 }
@@ -307,14 +307,14 @@ func (api *API) EditChatInviteLink(params EditChatInviteLinkP) (ChatInviteLink,
 // EditChatInviteLinkWithContext is the context-aware variant of EditChatInviteLink.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#editchatinvitelink
-func (api *API) EditChatInviteLinkWithContext(ctx context.Context, params EditChatInviteLinkP) (ChatInviteLink, error) {
+func (api *API) EditChatInviteLinkWithContext(ctx context.Context, params EditChatInviteLink) (ChatInviteLink, error) {
 	req := NewRequestWithChatID[ChatInviteLink]("editChatInviteLink", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
 
-// CreateChatSubscriptionInviteLinkP holds parameters for the createChatSubscriptionInviteLink method.
+// CreateChatSubscriptionInviteLink holds parameters for the createChatSubscriptionInviteLink method.
 // See https://core.telegram.org/bots/api#createchatsubscriptioninvitelink
-type CreateChatSubscriptionInviteLinkP struct {
+type CreateChatSubscriptionInviteLink struct {
 	ChatID             int64  `json:"chat_id"`
 	Name               string `json:"name,omitempty"`
 	SubscriptionPeriod int    `json:"subscription_period,omitempty"`
@@ -324,7 +324,7 @@ type CreateChatSubscriptionInviteLinkP struct {
 // CreateChatSubscriptionInviteLink creates a subscription invite link for a channel chat.
 // Returns the created invite link.
 // See https://core.telegram.org/bots/api#createchatsubscriptioninvitelink
-func (api *API) CreateChatSubscriptionInviteLink(params CreateChatSubscriptionInviteLinkP) (ChatInviteLink, error) {
+func (api *API) CreateChatSubscriptionInviteLink(params CreateChatSubscriptionInviteLink) (ChatInviteLink, error) {
 	req := NewRequestWithChatID[ChatInviteLink]("createChatSubscriptionInviteLink", params, params.ChatID)
 	return req.Do(api)
 }
@@ -332,14 +332,14 @@ func (api *API) CreateChatSubscriptionInviteLink(params CreateChatSubscriptionIn
 // CreateChatSubscriptionInviteLinkWithContext is the context-aware variant of CreateChatSubscriptionInviteLink.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#createchatsubscriptioninvitelink
-func (api *API) CreateChatSubscriptionInviteLinkWithContext(ctx context.Context, params CreateChatSubscriptionInviteLinkP) (ChatInviteLink, error) {
+func (api *API) CreateChatSubscriptionInviteLinkWithContext(ctx context.Context, params CreateChatSubscriptionInviteLink) (ChatInviteLink, error) {
 	req := NewRequestWithChatID[ChatInviteLink]("createChatSubscriptionInviteLink", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
 
-// EditChatSubscriptionInviteLinkP holds parameters for the editChatSubscriptionInviteLink method.
+// EditChatSubscriptionInviteLink holds parameters for the editChatSubscriptionInviteLink method.
 // See https://core.telegram.org/bots/api#editchatsubscriptioninvitelink
-type EditChatSubscriptionInviteLinkP struct {
+type EditChatSubscriptionInviteLink struct {
 	ChatID     int64  `json:"chat_id"`
 	InviteLink string `json:"invite_link"`
 	Name       string `json:"name,omitempty"`
@@ -348,7 +348,7 @@ type EditChatSubscriptionInviteLinkP struct {
 // EditChatSubscriptionInviteLink edits a subscription invite link.
 // Returns the edited invite link.
 // See https://core.telegram.org/bots/api#editchatsubscriptioninvitelink
-func (api *API) EditChatSubscriptionInviteLink(params EditChatSubscriptionInviteLinkP) (ChatInviteLink, error) {
+func (api *API) EditChatSubscriptionInviteLink(params EditChatSubscriptionInviteLink) (ChatInviteLink, error) {
 	req := NewRequestWithChatID[ChatInviteLink]("editChatSubscriptionInviteLink", params, params.ChatID)
 	return req.Do(api)
 }
@@ -356,14 +356,14 @@ func (api *API) EditChatSubscriptionInviteLink(params EditChatSubscriptionInvite
 // EditChatSubscriptionInviteLinkWithContext is the context-aware variant of EditChatSubscriptionInviteLink.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#editchatsubscriptioninvitelink
-func (api *API) EditChatSubscriptionInviteLinkWithContext(ctx context.Context, params EditChatSubscriptionInviteLinkP) (ChatInviteLink, error) {
+func (api *API) EditChatSubscriptionInviteLinkWithContext(ctx context.Context, params EditChatSubscriptionInviteLink) (ChatInviteLink, error) {
 	req := NewRequestWithChatID[ChatInviteLink]("editChatSubscriptionInviteLink", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
 
-// RevokeChatInviteLinkP holds parameters for the revokeChatInviteLink method.
+// RevokeChatInviteLink holds parameters for the revokeChatInviteLink method.
 // See https://core.telegram.org/bots/api#revokechatinvitelink
-type RevokeChatInviteLinkP struct {
+type RevokeChatInviteLink struct {
 	ChatID     int64  `json:"chat_id"`
 	InviteLink string `json:"invite_link"`
 }
@@ -371,7 +371,7 @@ type RevokeChatInviteLinkP struct {
 // RevokeChatInviteLink revokes an invite link.
 // Returns the revoked invite link object.
 // See https://core.telegram.org/bots/api#revokechatinvitelink
-func (api *API) RevokeChatInviteLink(params RevokeChatInviteLinkP) (ChatInviteLink, error) {
+func (api *API) RevokeChatInviteLink(params RevokeChatInviteLink) (ChatInviteLink, error) {
 	req := NewRequestWithChatID[ChatInviteLink]("revokeChatInviteLink", params, params.ChatID)
 	return req.Do(api)
 }
@@ -379,14 +379,14 @@ func (api *API) RevokeChatInviteLink(params RevokeChatInviteLinkP) (ChatInviteLi
 // RevokeChatInviteLinkWithContext is the context-aware variant of RevokeChatInviteLink.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#revokechatinvitelink
-func (api *API) RevokeChatInviteLinkWithContext(ctx context.Context, params RevokeChatInviteLinkP) (ChatInviteLink, error) {
+func (api *API) RevokeChatInviteLinkWithContext(ctx context.Context, params RevokeChatInviteLink) (ChatInviteLink, error) {
 	req := NewRequestWithChatID[ChatInviteLink]("revokeChatInviteLink", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
 
-// ApproveChatJoinRequestP holds parameters for the approveChatJoinRequest method.
+// ApproveChatJoinRequest holds parameters for the approveChatJoinRequest method.
 // See https://core.telegram.org/bots/api#approvechatjoinrequest
-type ApproveChatJoinRequestP struct {
+type ApproveChatJoinRequest struct {
 	ChatID int64 `json:"chat_id"`
 	UserID int64 `json:"user_id"`
 }
@@ -394,7 +394,7 @@ type ApproveChatJoinRequestP struct {
 // ApproveChatJoinRequest approves a chat join request.
 // Returns True on success.
 // See https://core.telegram.org/bots/api#approvechatjoinrequest
-func (api *API) ApproveChatJoinRequest(params ApproveChatJoinRequestP) (bool, error) {
+func (api *API) ApproveChatJoinRequest(params ApproveChatJoinRequest) (bool, error) {
 	req := NewRequestWithChatID[bool]("approveChatJoinRequest", params, params.ChatID)
 	return req.Do(api)
 }
@@ -402,14 +402,14 @@ func (api *API) ApproveChatJoinRequest(params ApproveChatJoinRequestP) (bool, er
 // ApproveChatJoinRequestWithContext is the context-aware variant of ApproveChatJoinRequest.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#approvechatjoinrequest
-func (api *API) ApproveChatJoinRequestWithContext(ctx context.Context, params ApproveChatJoinRequestP) (bool, error) {
+func (api *API) ApproveChatJoinRequestWithContext(ctx context.Context, params ApproveChatJoinRequest) (bool, error) {
 	req := NewRequestWithChatID[bool]("approveChatJoinRequest", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
 
-// DeclineChatJoinRequestP holds parameters for the declineChatJoinRequest method.
+// DeclineChatJoinRequest holds parameters for the declineChatJoinRequest method.
 // See https://core.telegram.org/bots/api#declinechatjoinrequest
-type DeclineChatJoinRequestP struct {
+type DeclineChatJoinRequest struct {
 	ChatID int64 `json:"chat_id"`
 	UserID int64 `json:"user_id"`
 }
@@ -417,7 +417,7 @@ type DeclineChatJoinRequestP struct {
 // DeclineChatJoinRequest declines a chat join request.
 // Returns True on success.
 // See https://core.telegram.org/bots/api#declinechatjoinrequest
-func (api *API) DeclineChatJoinRequest(params DeclineChatJoinRequestP) (bool, error) {
+func (api *API) DeclineChatJoinRequest(params DeclineChatJoinRequest) (bool, error) {
 	req := NewRequestWithChatID[bool]("declineChatJoinRequest", params, params.ChatID)
 	return req.Do(api)
 }
@@ -425,14 +425,14 @@ func (api *API) DeclineChatJoinRequest(params DeclineChatJoinRequestP) (bool, er
 // DeclineChatJoinRequestWithContext is the context-aware variant of DeclineChatJoinRequest.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#declinechatjoinrequest
-func (api *API) DeclineChatJoinRequestWithContext(ctx context.Context, params DeclineChatJoinRequestP) (bool, error) {
+func (api *API) DeclineChatJoinRequestWithContext(ctx context.Context, params DeclineChatJoinRequest) (bool, error) {
 	req := NewRequestWithChatID[bool]("declineChatJoinRequest", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
 
-// SetChatPhotoP holds parameters for the setChatPhoto method.
+// SetChatPhoto holds parameters for the setChatPhoto method.
 // See https://core.telegram.org/bots/api#setchatphoto
-type SetChatPhotoP struct {
+type SetChatPhoto struct {
 	ChatID int64 `json:"chat_id"`
 }
 
@@ -440,7 +440,7 @@ type SetChatPhotoP struct {
 // photo is the file to upload as the new photo.
 // Returns True on success.
 // See https://core.telegram.org/bots/api#setchatphoto
-func (api *API) SetChatPhoto(params SetChatPhotoP, photo UploaderFile) (bool, error) {
+func (api *API) SetChatPhoto(params SetChatPhoto, photo UploaderFile) (bool, error) {
 	uploader := NewUploader(api)
 	defer func() {
 		_ = uploader.Close()
@@ -449,16 +449,16 @@ func (api *API) SetChatPhoto(params SetChatPhotoP, photo UploaderFile) (bool, er
 	return req.Do(uploader)
 }
 
-// DeleteChatPhotoP holds parameters for the deleteChatPhoto method.
+// DeleteChatPhoto holds parameters for the deleteChatPhoto method.
 // See https://core.telegram.org/bots/api#deletechatphoto
-type DeleteChatPhotoP struct {
+type DeleteChatPhoto struct {
 	ChatID int64 `json:"chat_id"`
 }
 
 // DeleteChatPhoto deletes a chat photo.
 // Returns True on success.
 // See https://core.telegram.org/bots/api#deletechatphoto
-func (api *API) DeleteChatPhoto(params DeleteChatPhotoP) (bool, error) {
+func (api *API) DeleteChatPhoto(params DeleteChatPhoto) (bool, error) {
 	req := NewRequestWithChatID[bool]("deleteChatPhoto", params, params.ChatID)
 	return req.Do(api)
 }
@@ -466,14 +466,14 @@ func (api *API) DeleteChatPhoto(params DeleteChatPhotoP) (bool, error) {
 // DeleteChatPhotoWithContext is the context-aware variant of DeleteChatPhoto.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#deletechatphoto
-func (api *API) DeleteChatPhotoWithContext(ctx context.Context, params DeleteChatPhotoP) (bool, error) {
+func (api *API) DeleteChatPhotoWithContext(ctx context.Context, params DeleteChatPhoto) (bool, error) {
 	req := NewRequestWithChatID[bool]("deleteChatPhoto", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
 
-// SetChatTitleP holds parameters for the setChatTitle method.
+// SetChatTitle holds parameters for the setChatTitle method.
 // See https://core.telegram.org/bots/api#setchattitle
-type SetChatTitleP struct {
+type SetChatTitle struct {
 	ChatID int64  `json:"chat_id"`
 	Title  string `json:"title"`
 }
@@ -481,7 +481,7 @@ type SetChatTitleP struct {
 // SetChatTitle changes the chat title.
 // Returns True on success.
 // See https://core.telegram.org/bots/api#setchattitle
-func (api *API) SetChatTitle(params SetChatTitleP) (bool, error) {
+func (api *API) SetChatTitle(params SetChatTitle) (bool, error) {
 	req := NewRequestWithChatID[bool]("setChatTitle", params, params.ChatID)
 	return req.Do(api)
 }
@@ -489,14 +489,14 @@ func (api *API) SetChatTitle(params SetChatTitleP) (bool, error) {
 // SetChatTitleWithContext is the context-aware variant of SetChatTitle.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#setchattitle
-func (api *API) SetChatTitleWithContext(ctx context.Context, params SetChatTitleP) (bool, error) {
+func (api *API) SetChatTitleWithContext(ctx context.Context, params SetChatTitle) (bool, error) {
 	req := NewRequestWithChatID[bool]("setChatTitle", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
 
-// SetChatDescriptionP holds parameters for the setChatDescription method.
+// SetChatDescription holds parameters for the setChatDescription method.
 // See https://core.telegram.org/bots/api#setchatdescription
-type SetChatDescriptionP struct {
+type SetChatDescription struct {
 	ChatID      int64  `json:"chat_id"`
 	Description string `json:"description"`
 }
@@ -504,7 +504,7 @@ type SetChatDescriptionP struct {
 // SetChatDescription changes the chat description.
 // Returns True on success.
 // See https://core.telegram.org/bots/api#setchatdescription
-func (api *API) SetChatDescription(params SetChatDescriptionP) (bool, error) {
+func (api *API) SetChatDescription(params SetChatDescription) (bool, error) {
 	req := NewRequestWithChatID[bool]("setChatDescription", params, params.ChatID)
 	return req.Do(api)
 }
@@ -512,14 +512,14 @@ func (api *API) SetChatDescription(params SetChatDescriptionP) (bool, error) {
 // SetChatDescriptionWithContext is the context-aware variant of SetChatDescription.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#setchatdescription
-func (api *API) SetChatDescriptionWithContext(ctx context.Context, params SetChatDescriptionP) (bool, error) {
+func (api *API) SetChatDescriptionWithContext(ctx context.Context, params SetChatDescription) (bool, error) {
 	req := NewRequestWithChatID[bool]("setChatDescription", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
 
-// PinChatMessageP holds parameters for the pinChatMessage method.
+// PinChatMessage holds parameters for the pinChatMessage method.
 // See https://core.telegram.org/bots/api#pinchatmessage
-type PinChatMessageP struct {
+type PinChatMessage struct {
 	BusinessConnectionID *string `json:"business_connection_id,omitempty"`
 	ChatID               int64   `json:"chat_id"`
 	MessageID            int     `json:"message_id"`
@@ -529,7 +529,7 @@ type PinChatMessageP struct {
 // PinChatMessage pins a message in a chat.
 // Returns True on success.
 // See https://core.telegram.org/bots/api#pinchatmessage
-func (api *API) PinChatMessage(params PinChatMessageP) (bool, error) {
+func (api *API) PinChatMessage(params PinChatMessage) (bool, error) {
 	req := NewRequestWithChatID[bool]("pinChatMessage", params, params.ChatID)
 	return req.Do(api)
 }
@@ -537,14 +537,14 @@ func (api *API) PinChatMessage(params PinChatMessageP) (bool, error) {
 // PinChatMessageWithContext is the context-aware variant of PinChatMessage.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#pinchatmessage
-func (api *API) PinChatMessageWithContext(ctx context.Context, params PinChatMessageP) (bool, error) {
+func (api *API) PinChatMessageWithContext(ctx context.Context, params PinChatMessage) (bool, error) {
 	req := NewRequestWithChatID[bool]("pinChatMessage", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
 
-// UnpinChatMessageP holds parameters for the unpinChatMessage method.
+// UnpinChatMessage holds parameters for the unpinChatMessage method.
 // See https://core.telegram.org/bots/api#unpinchatmessage
-type UnpinChatMessageP struct {
+type UnpinChatMessage struct {
 	BusinessConnectionID *string `json:"business_connection_id,omitempty"`
 	ChatID               int64   `json:"chat_id"`
 	MessageID            int     `json:"message_id"`
@@ -553,7 +553,7 @@ type UnpinChatMessageP struct {
 // UnpinChatMessage unpins a message in a chat.
 // Returns True on success.
 // See https://core.telegram.org/bots/api#unpinchatmessage
-func (api *API) UnpinChatMessage(params UnpinChatMessageP) (bool, error) {
+func (api *API) UnpinChatMessage(params UnpinChatMessage) (bool, error) {
 	req := NewRequestWithChatID[bool]("unpinChatMessage", params, params.ChatID)
 	return req.Do(api)
 }
@@ -561,21 +561,21 @@ func (api *API) UnpinChatMessage(params UnpinChatMessageP) (bool, error) {
 // UnpinChatMessageWithContext is the context-aware variant of UnpinChatMessage.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#unpinchatmessage
-func (api *API) UnpinChatMessageWithContext(ctx context.Context, params UnpinChatMessageP) (bool, error) {
+func (api *API) UnpinChatMessageWithContext(ctx context.Context, params UnpinChatMessage) (bool, error) {
 	req := NewRequestWithChatID[bool]("unpinChatMessage", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
 
-// UnpinAllChatMessagesP holds parameters for the unpinAllChatMessages method.
+// UnpinAllChatMessages holds parameters for the unpinAllChatMessages method.
 // See https://core.telegram.org/bots/api#unpinallchatmessages
-type UnpinAllChatMessagesP struct {
+type UnpinAllChatMessages struct {
 	ChatID int64 `json:"chat_id"`
 }
 
 // UnpinAllChatMessages unpins all pinned messages in a chat.
 // Returns True on success.
 // See https://core.telegram.org/bots/api#unpinallchatmessages
-func (api *API) UnpinAllChatMessages(params UnpinAllChatMessagesP) (bool, error) {
+func (api *API) UnpinAllChatMessages(params UnpinAllChatMessages) (bool, error) {
 	req := NewRequestWithChatID[bool]("unpinAllChatMessages", params, params.ChatID)
 	return req.Do(api)
 }
@@ -583,21 +583,21 @@ func (api *API) UnpinAllChatMessages(params UnpinAllChatMessagesP) (bool, error)
 // UnpinAllChatMessagesWithContext is the context-aware variant of UnpinAllChatMessages.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#unpinallchatmessages
-func (api *API) UnpinAllChatMessagesWithContext(ctx context.Context, params UnpinAllChatMessagesP) (bool, error) {
+func (api *API) UnpinAllChatMessagesWithContext(ctx context.Context, params UnpinAllChatMessages) (bool, error) {
 	req := NewRequestWithChatID[bool]("unpinAllChatMessages", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
 
-// LeaveChatP holds parameters for the leaveChat method.
+// LeaveChat holds parameters for the leaveChat method.
 // See https://core.telegram.org/bots/api#leavechat
-type LeaveChatP struct {
+type LeaveChat struct {
 	ChatID int64 `json:"chat_id"`
 }
 
 // LeaveChat makes the bot leave a chat.
 // Returns True on success.
 // See https://core.telegram.org/bots/api#leavechat
-func (api *API) LeaveChat(params LeaveChatP) (bool, error) {
+func (api *API) LeaveChat(params LeaveChat) (bool, error) {
 	req := NewRequestWithChatID[bool]("leaveChat", params, params.ChatID) // fixed method name
 	return req.Do(api)
 }
@@ -605,20 +605,20 @@ func (api *API) LeaveChat(params LeaveChatP) (bool, error) {
 // LeaveChatWithContext is the context-aware variant of LeaveChat.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#leavechat
-func (api *API) LeaveChatWithContext(ctx context.Context, params LeaveChatP) (bool, error) {
+func (api *API) LeaveChatWithContext(ctx context.Context, params LeaveChat) (bool, error) {
 	req := NewRequestWithChatID[bool]("leaveChat", params, params.ChatID) // fixed method name
 	return req.DoWithContext(ctx, api)
 }
 
-// GetChatP holds parameters for the getChat method.
+// GetChat holds parameters for the getChat method.
 // See https://core.telegram.org/bots/api#getchat
-type GetChatP struct {
+type GetChat struct {
 	ChatID int64 `json:"chat_id"`
 }
 
 // GetChat gets up‑to‑date information about a chat.
 // See https://core.telegram.org/bots/api#getchat
-func (api *API) GetChat(params GetChatP) (ChatFullInfo, error) {
+func (api *API) GetChat(params GetChat) (ChatFullInfo, error) {
 	req := NewRequestWithChatID[ChatFullInfo]("getChat", params, params.ChatID) // fixed method name
 	return req.Do(api)
 }
@@ -626,20 +626,20 @@ func (api *API) GetChat(params GetChatP) (ChatFullInfo, error) {
 // GetChatWithContext is the context-aware variant of GetChat.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#getchat
-func (api *API) GetChatWithContext(ctx context.Context, params GetChatP) (ChatFullInfo, error) {
+func (api *API) GetChatWithContext(ctx context.Context, params GetChat) (ChatFullInfo, error) {
 	req := NewRequestWithChatID[ChatFullInfo]("getChat", params, params.ChatID) // fixed method name
 	return req.DoWithContext(ctx, api)
 }
 
-// GetChatAdministratorsP holds parameters for the getChatAdministrators method.
+// GetChatAdministrators holds parameters for the getChatAdministrators method.
 // See https://core.telegram.org/bots/api#getchatadministrators
-type GetChatAdministratorsP struct {
+type GetChatAdministrators struct {
 	ChatID int64 `json:"chat_id"`
 }
 
 // GetChatAdministrators returns a list of administrators in a chat.
 // See https://core.telegram.org/bots/api#getchatadministrators
-func (api *API) GetChatAdministrators(params GetChatAdministratorsP) ([]ChatMember, error) {
+func (api *API) GetChatAdministrators(params GetChatAdministrators) ([]ChatMember, error) {
 	req := NewRequestWithChatID[[]ChatMember]("getChatAdministrators", params, params.ChatID)
 	return req.Do(api)
 }
@@ -647,20 +647,20 @@ func (api *API) GetChatAdministrators(params GetChatAdministratorsP) ([]ChatMemb
 // GetChatAdministratorsWithContext is the context-aware variant of GetChatAdministrators.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#getchatadministrators
-func (api *API) GetChatAdministratorsWithContext(ctx context.Context, params GetChatAdministratorsP) ([]ChatMember, error) {
+func (api *API) GetChatAdministratorsWithContext(ctx context.Context, params GetChatAdministrators) ([]ChatMember, error) {
 	req := NewRequestWithChatID[[]ChatMember]("getChatAdministrators", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
 
-// GetChatMembersCountP holds parameters for the getChatMemberCount method.
+// GetChatMembersCount holds parameters for the getChatMemberCount method.
 // See https://core.telegram.org/bots/api#getchatmembercount
-type GetChatMembersCountP struct {
+type GetChatMembersCount struct {
 	ChatID int64 `json:"chat_id"`
 }
 
 // GetChatMemberCount returns the number of members in a chat.
 // See https://core.telegram.org/bots/api#getchatmembercount
-func (api *API) GetChatMemberCount(params GetChatMembersCountP) (int, error) {
+func (api *API) GetChatMemberCount(params GetChatMembersCount) (int, error) {
 	req := NewRequestWithChatID[int]("getChatMemberCount", params, params.ChatID)
 	return req.Do(api)
 }
@@ -668,21 +668,21 @@ func (api *API) GetChatMemberCount(params GetChatMembersCountP) (int, error) {
 // GetChatMemberCountWithContext is the context-aware variant of GetChatMemberCount.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#getchatmembercount
-func (api *API) GetChatMemberCountWithContext(ctx context.Context, params GetChatMembersCountP) (int, error) {
+func (api *API) GetChatMemberCountWithContext(ctx context.Context, params GetChatMembersCount) (int, error) {
 	req := NewRequestWithChatID[int]("getChatMemberCount", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
 
-// GetChatMemberP holds parameters for the getChatMember method.
+// GetChatMember holds parameters for the getChatMember method.
 // See https://core.telegram.org/bots/api#getchatmember
-type GetChatMemberP struct {
+type GetChatMember struct {
 	ChatID int64 `json:"chat_id"`
 	UserID int64 `json:"user_id"`
 }
 
 // GetChatMember returns information about a member of a chat.
 // See https://core.telegram.org/bots/api#getchatmember
-func (api *API) GetChatMember(params GetChatMemberP) (ChatMember, error) {
+func (api *API) GetChatMember(params GetChatMember) (ChatMember, error) {
 	req := NewRequestWithChatID[ChatMember]("getChatMember", params, params.ChatID)
 	return req.Do(api)
 }
@@ -690,14 +690,14 @@ func (api *API) GetChatMember(params GetChatMemberP) (ChatMember, error) {
 // GetChatMemberWithContext is the context-aware variant of GetChatMember.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#getchatmember
-func (api *API) GetChatMemberWithContext(ctx context.Context, params GetChatMemberP) (ChatMember, error) {
+func (api *API) GetChatMemberWithContext(ctx context.Context, params GetChatMember) (ChatMember, error) {
 	req := NewRequestWithChatID[ChatMember]("getChatMember", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
 
-// SetChatStickerSetP holds parameters for the setChatStickerSet method.
+// SetChatStickerSet holds parameters for the setChatStickerSet method.
 // See https://core.telegram.org/bots/api#setchatstickerset
-type SetChatStickerSetP struct {
+type SetChatStickerSet struct {
 	ChatID         int64  `json:"chat_id"`
 	StickerSetName string `json:"sticker_set_name"`
 }
@@ -705,7 +705,7 @@ type SetChatStickerSetP struct {
 // SetChatStickerSet associates a sticker set with a supergroup.
 // Returns True on success.
 // See https://core.telegram.org/bots/api#setchatstickerset
-func (api *API) SetChatStickerSet(params SetChatStickerSetP) (bool, error) {
+func (api *API) SetChatStickerSet(params SetChatStickerSet) (bool, error) {
 	req := NewRequestWithChatID[bool]("setChatStickerSet", params, params.ChatID)
 	return req.Do(api)
 }
@@ -713,21 +713,21 @@ func (api *API) SetChatStickerSet(params SetChatStickerSetP) (bool, error) {
 // SetChatStickerSetWithContext is the context-aware variant of SetChatStickerSet.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#setchatstickerset
-func (api *API) SetChatStickerSetWithContext(ctx context.Context, params SetChatStickerSetP) (bool, error) {
+func (api *API) SetChatStickerSetWithContext(ctx context.Context, params SetChatStickerSet) (bool, error) {
 	req := NewRequestWithChatID[bool]("setChatStickerSet", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
 
-// DeleteChatStickerSetP holds parameters for the deleteChatStickerSet method.
+// DeleteChatStickerSet holds parameters for the deleteChatStickerSet method.
 // See https://core.telegram.org/bots/api#deletechatstickerset
-type DeleteChatStickerSetP struct {
+type DeleteChatStickerSet struct {
 	ChatID int64 `json:"chat_id"`
 }
 
 // DeleteChatStickerSet deletes a sticker set from a supergroup.
 // Returns True on success.
 // See https://core.telegram.org/bots/api#deletechatstickerset
-func (api *API) DeleteChatStickerSet(params DeleteChatStickerSetP) (bool, error) {
+func (api *API) DeleteChatStickerSet(params DeleteChatStickerSet) (bool, error) {
 	req := NewRequestWithChatID[bool]("deleteChatStickerSet", params, params.ChatID)
 	return req.Do(api)
 }
@@ -735,21 +735,21 @@ func (api *API) DeleteChatStickerSet(params DeleteChatStickerSetP) (bool, error)
 // DeleteChatStickerSetWithContext is the context-aware variant of DeleteChatStickerSet.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#deletechatstickerset
-func (api *API) DeleteChatStickerSetWithContext(ctx context.Context, params DeleteChatStickerSetP) (bool, error) {
+func (api *API) DeleteChatStickerSetWithContext(ctx context.Context, params DeleteChatStickerSet) (bool, error) {
 	req := NewRequestWithChatID[bool]("deleteChatStickerSet", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
 
-// GetUserChatBoostsP holds parameters for the getUserChatBoosts method.
+// GetUserChatBoosts holds parameters for the getUserChatBoosts method.
 // See https://core.telegram.org/bots/api#getuserchatboosts
-type GetUserChatBoostsP struct {
+type GetUserChatBoosts struct {
 	ChatID int64 `json:"chat_id"`
 	UserID int64 `json:"user_id"`
 }
 
 // GetUserChatBoosts returns the list of boosts a user has given to a chat.
 // See https://core.telegram.org/bots/api#getuserchatboosts
-func (api *API) GetUserChatBoosts(params GetUserChatBoostsP) (UserChatBoosts, error) {
+func (api *API) GetUserChatBoosts(params GetUserChatBoosts) (UserChatBoosts, error) {
 	req := NewRequestWithChatID[UserChatBoosts]("getUserChatBoosts", params, params.ChatID)
 	return req.Do(api)
 }
@@ -757,14 +757,14 @@ func (api *API) GetUserChatBoosts(params GetUserChatBoostsP) (UserChatBoosts, er
 // GetUserChatBoostsWithContext is the context-aware variant of GetUserChatBoosts.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#getuserchatboosts
-func (api *API) GetUserChatBoostsWithContext(ctx context.Context, params GetUserChatBoostsP) (UserChatBoosts, error) {
+func (api *API) GetUserChatBoostsWithContext(ctx context.Context, params GetUserChatBoosts) (UserChatBoosts, error) {
 	req := NewRequestWithChatID[UserChatBoosts]("getUserChatBoosts", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
 
-// GetChatGiftsP holds parameters for the getChatGifts method.
+// GetChatGifts holds parameters for the getChatGifts method.
 // See https://core.telegram.org/bots/api#getchatgifts
-type GetChatGiftsP struct {
+type GetChatGifts struct {
 	ChatID                      int64  `json:"chat_id"`
 	ExcludeUnsaved              bool   `json:"exclude_unsaved,omitempty"`
 	ExcludeSaved                bool   `json:"exclude_saved,omitempty"`
@@ -780,7 +780,7 @@ type GetChatGiftsP struct {
 
 // GetChatGifts returns gifts owned by a chat.
 // See https://core.telegram.org/bots/api#getchatgifts
-func (api *API) GetChatGifts(params GetChatGiftsP) (OwnedGifts, error) {
+func (api *API) GetChatGifts(params GetChatGifts) (OwnedGifts, error) {
 	req := NewRequestWithChatID[OwnedGifts]("getChatGifts", params, params.ChatID)
 	return req.Do(api)
 }
@@ -788,7 +788,7 @@ func (api *API) GetChatGifts(params GetChatGiftsP) (OwnedGifts, error) {
 // GetChatGiftsWithContext is the context-aware variant of GetChatGifts.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#getchatgifts
-func (api *API) GetChatGiftsWithContext(ctx context.Context, params GetChatGiftsP) (OwnedGifts, error) {
+func (api *API) GetChatGiftsWithContext(ctx context.Context, params GetChatGifts) (OwnedGifts, error) {
 	req := NewRequestWithChatID[OwnedGifts]("getChatGifts", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }

tgapi/chat_types.go

@@ -107,11 +107,12 @@ type ChatPermissions struct {
 	CanSendAudios        bool `json:"can_send_audios"`
 	CanSendDocuments     bool `json:"can_send_documents"`
 	CanSendPhotos        bool `json:"can_send_photos"`
+	CanSendVideos        bool `json:"can_send_videos"`
 	CanSendVideoNotes    bool `json:"can_send_video_notes"`
 	CanSendVoiceNotes    bool `json:"can_send_voice_notes"`
 	CanSendPolls         bool `json:"can_send_polls"`
 	CanSendOtherMessages bool `json:"can_send_other_messages"`
-	CanAddWebPagePreview bool `json:"can_add_web_page_preview"`
+	CanAddWebPagePreview bool `json:"can_add_web_page_previews"`
 	CanEditTag           bool `json:"can_edit_tag"`
 	CanChangeInfo        bool `json:"can_change_info"`
 	CanInviteUsers       bool `json:"can_invite_users"`
@@ -200,12 +201,13 @@ type ChatMember struct {
 	CanSendMessages      *bool `json:"can_send_messages,omitempty"`
 	CanSendAudios        *bool `json:"can_send_audios,omitempty"`
 	CanSendDocuments     *bool `json:"can_send_documents,omitempty"`
+	CanSendPhotos        *bool `json:"can_send_photos,omitempty"`
 	CanSendVideos        *bool `json:"can_send_videos,omitempty"`
 	CanSendVideoNotes    *bool `json:"can_send_video_notes,omitempty"`
 	CanSendVoiceNotes    *bool `json:"can_send_voice_notes,omitempty"`
 	CanSendPolls         *bool `json:"can_send_polls,omitempty"`
 	CanSendOtherMessages *bool `json:"can_send_other_messages,omitempty"`
-	CanAddWebPagePreview *bool `json:"can_add_web_page_preview,omitempty"`
+	CanAddWebPagePreview *bool `json:"can_add_web_page_previews,omitempty"`
 	CanEditTag           *bool `json:"can_edit_tag,omitempty"`
 }
 
@@ -235,6 +237,25 @@ type ChatBoost struct {
 type UserChatBoosts struct {
 	Boosts []ChatBoost `json:"boosts"`
 }
+type ChatBoostAdded struct {
+	BoostCount int `json:"boost_count"`
+}
+
+type ChatBackground struct {
+	Type BackgroundType `json:"type"`
+}
+
+// ChatOwnerLeft describes a service message about a chat owner leaving.
+// See https://core.telegram.org/bots/api#chatownerleft
+type ChatOwnerLeft struct {
+	NewOwner *User `json:"new_owner,omitempty"`
+}
+
+// ChatOwnerChanged describes a service message about a chat owner change.
+// See https://core.telegram.org/bots/api#chatownerchanged
+type ChatOwnerChanged struct {
+	NewOwner User `json:"new_owner"`
+}
 
 // ChatAdministratorRights represents the rights of an administrator in a chat.
 // See https://core.telegram.org/bots/api#chatadministratorrights

tgapi/forum_methods.go

@@ -2,8 +2,8 @@ package tgapi
 
 import "context"
 
-// BaseForumTopicP contains common fields for forum topic operations that require a chat ID and a message thread ID.
-type BaseForumTopicP struct {
+// BaseForumTopic contains common fields for forum topic operations that require a chat ID and a message thread ID.
+type BaseForumTopic struct {
 	ChatID          int64 `json:"chat_id"`
 	MessageThreadID int   `json:"message_thread_id"`
 }
@@ -23,9 +23,9 @@ func (api *API) GetForumTopicIconStickersWithContext(ctx context.Context) ([]Sti
 	return req.DoWithContext(ctx, api)
 }
 
-// CreateForumTopicP holds parameters for the createForumTopic method.
+// CreateForumTopic holds parameters for the createForumTopic method.
 // See https://core.telegram.org/bots/api#createforumtopic
-type CreateForumTopicP struct {
+type CreateForumTopic struct {
 	ChatID            int64               `json:"chat_id"`
 	Name              string              `json:"name"`
 	IconColor         ForumTopicIconColor `json:"icon_color"`
@@ -35,7 +35,7 @@ type CreateForumTopicP struct {
 // CreateForumTopic creates a topic in a forum supergroup.
 // Returns the created ForumTopic on success.
 // See https://core.telegram.org/bots/api#createforumtopic
-func (api *API) CreateForumTopic(params CreateForumTopicP) (ForumTopic, error) {
+func (api *API) CreateForumTopic(params CreateForumTopic) (ForumTopic, error) {
 	req := NewRequestWithChatID[ForumTopic]("createForumTopic", params, params.ChatID)
 	return req.Do(api)
 }
@@ -43,15 +43,15 @@ func (api *API) CreateForumTopic(params CreateForumTopicP) (ForumTopic, error) {
 // CreateForumTopicWithContext is the context-aware variant of CreateForumTopic.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#createforumtopic
-func (api *API) CreateForumTopicWithContext(ctx context.Context, params CreateForumTopicP) (ForumTopic, error) {
+func (api *API) CreateForumTopicWithContext(ctx context.Context, params CreateForumTopic) (ForumTopic, error) {
 	req := NewRequestWithChatID[ForumTopic]("createForumTopic", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
 
-// EditForumTopicP holds parameters for the editForumTopic method.
+// EditForumTopic holds parameters for the editForumTopic method.
 // See https://core.telegram.org/bots/api#editforumtopic
-type EditForumTopicP struct {
-	BaseForumTopicP
+type EditForumTopic struct {
+	BaseForumTopic
 	Name              string `json:"name"`
 	IconCustomEmojiID string `json:"icon_custom_emoji_id"`
 }
@@ -59,7 +59,7 @@ type EditForumTopicP struct {
 // EditForumTopic edits name and icon of a forum topic.
 // Returns True on success.
 // See https://core.telegram.org/bots/api#editforumtopic
-func (api *API) EditForumTopic(params EditForumTopicP) (bool, error) {
+func (api *API) EditForumTopic(params EditForumTopic) (bool, error) {
 	req := NewRequestWithChatID[bool]("editForumTopic", params, params.ChatID)
 	return req.Do(api)
 }
@@ -67,7 +67,7 @@ func (api *API) EditForumTopic(params EditForumTopicP) (bool, error) {
 // EditForumTopicWithContext is the context-aware variant of EditForumTopic.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#editforumtopic
-func (api *API) EditForumTopicWithContext(ctx context.Context, params EditForumTopicP) (bool, error) {
+func (api *API) EditForumTopicWithContext(ctx context.Context, params EditForumTopic) (bool, error) {
 	req := NewRequestWithChatID[bool]("editForumTopic", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
@@ -75,7 +75,7 @@ func (api *API) EditForumTopicWithContext(ctx context.Context, params EditForumT
 // CloseForumTopic closes an open forum topic.
 // Returns True on success.
 // See https://core.telegram.org/bots/api#closeforumtopic
-func (api *API) CloseForumTopic(params BaseForumTopicP) (bool, error) {
+func (api *API) CloseForumTopic(params BaseForumTopic) (bool, error) {
 	req := NewRequestWithChatID[bool]("closeForumTopic", params, params.ChatID)
 	return req.Do(api)
 }
@@ -83,7 +83,7 @@ func (api *API) CloseForumTopic(params BaseForumTopicP) (bool, error) {
 // CloseForumTopicWithContext is the context-aware variant of CloseForumTopic.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#closeforumtopic
-func (api *API) CloseForumTopicWithContext(ctx context.Context, params BaseForumTopicP) (bool, error) {
+func (api *API) CloseForumTopicWithContext(ctx context.Context, params BaseForumTopic) (bool, error) {
 	req := NewRequestWithChatID[bool]("closeForumTopic", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
@@ -91,7 +91,7 @@ func (api *API) CloseForumTopicWithContext(ctx context.Context, params BaseForum
 // ReopenForumTopic reopens a closed forum topic.
 // Returns True on success.
 // See https://core.telegram.org/bots/api#reopenforumtopic
-func (api *API) ReopenForumTopic(params BaseForumTopicP) (bool, error) {
+func (api *API) ReopenForumTopic(params BaseForumTopic) (bool, error) {
 	req := NewRequestWithChatID[bool]("reopenForumTopic", params, params.ChatID)
 	return req.Do(api)
 }
@@ -99,7 +99,7 @@ func (api *API) ReopenForumTopic(params BaseForumTopicP) (bool, error) {
 // ReopenForumTopicWithContext is the context-aware variant of ReopenForumTopic.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#reopenforumtopic
-func (api *API) ReopenForumTopicWithContext(ctx context.Context, params BaseForumTopicP) (bool, error) {
+func (api *API) ReopenForumTopicWithContext(ctx context.Context, params BaseForumTopic) (bool, error) {
 	req := NewRequestWithChatID[bool]("reopenForumTopic", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
@@ -107,7 +107,7 @@ func (api *API) ReopenForumTopicWithContext(ctx context.Context, params BaseForu
 // DeleteForumTopic deletes a forum topic.
 // Returns True on success.
 // See https://core.telegram.org/bots/api#deleteforumtopic
-func (api *API) DeleteForumTopic(params BaseForumTopicP) (bool, error) {
+func (api *API) DeleteForumTopic(params BaseForumTopic) (bool, error) {
 	req := NewRequestWithChatID[bool]("deleteForumTopic", params, params.ChatID)
 	return req.Do(api)
 }
@@ -115,7 +115,7 @@ func (api *API) DeleteForumTopic(params BaseForumTopicP) (bool, error) {
 // DeleteForumTopicWithContext is the context-aware variant of DeleteForumTopic.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#deleteforumtopic
-func (api *API) DeleteForumTopicWithContext(ctx context.Context, params BaseForumTopicP) (bool, error) {
+func (api *API) DeleteForumTopicWithContext(ctx context.Context, params BaseForumTopic) (bool, error) {
 	req := NewRequestWithChatID[bool]("deleteForumTopic", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
@@ -123,7 +123,7 @@ func (api *API) DeleteForumTopicWithContext(ctx context.Context, params BaseForu
 // UnpinAllForumTopicMessages clears the list of pinned messages in a forum topic.
 // Returns True on success.
 // See https://core.telegram.org/bots/api#unpinallforumtopicmessages
-func (api *API) UnpinAllForumTopicMessages(params BaseForumTopicP) (bool, error) {
+func (api *API) UnpinAllForumTopicMessages(params BaseForumTopic) (bool, error) {
 	req := NewRequestWithChatID[bool]("unpinAllForumTopicMessages", params, params.ChatID)
 	return req.Do(api)
 }
@@ -131,19 +131,19 @@ func (api *API) UnpinAllForumTopicMessages(params BaseForumTopicP) (bool, error)
 // UnpinAllForumTopicMessagesWithContext is the context-aware variant of UnpinAllForumTopicMessages.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#unpinallforumtopicmessages
-func (api *API) UnpinAllForumTopicMessagesWithContext(ctx context.Context, params BaseForumTopicP) (bool, error) {
+func (api *API) UnpinAllForumTopicMessagesWithContext(ctx context.Context, params BaseForumTopic) (bool, error) {
 	req := NewRequestWithChatID[bool]("unpinAllForumTopicMessages", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
 
-// BaseGeneralForumTopicP contains common fields for general forum topic operations that require a chat ID.
-type BaseGeneralForumTopicP struct {
+// BaseGeneralForumTopic contains common fields for general forum topic operations that require a chat ID.
+type BaseGeneralForumTopic struct {
 	ChatID int64 `json:"chat_id"`
 }
 
-// EditGeneralForumTopicP holds parameters for the editGeneralForumTopic method.
+// EditGeneralForumTopic holds parameters for the editGeneralForumTopic method.
 // See https://core.telegram.org/bots/api#editgeneralforumtopic
-type EditGeneralForumTopicP struct {
+type EditGeneralForumTopic struct {
 	ChatID int64  `json:"chat_id"`
 	Name   string `json:"name"`
 }
@@ -151,7 +151,7 @@ type EditGeneralForumTopicP struct {
 // EditGeneralForumTopic edits the name of the 'General' topic in a forum supergroup.
 // Returns True on success.
 // See https://core.telegram.org/bots/api#editgeneralforumtopic
-func (api *API) EditGeneralForumTopic(params EditGeneralForumTopicP) (bool, error) {
+func (api *API) EditGeneralForumTopic(params EditGeneralForumTopic) (bool, error) {
 	req := NewRequestWithChatID[bool]("editGeneralForumTopic", params, params.ChatID)
 	return req.Do(api)
 }
@@ -159,7 +159,7 @@ func (api *API) EditGeneralForumTopic(params EditGeneralForumTopicP) (bool, erro
 // EditGeneralForumTopicWithContext is the context-aware variant of EditGeneralForumTopic.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#editgeneralforumtopic
-func (api *API) EditGeneralForumTopicWithContext(ctx context.Context, params EditGeneralForumTopicP) (bool, error) {
+func (api *API) EditGeneralForumTopicWithContext(ctx context.Context, params EditGeneralForumTopic) (bool, error) {
 	req := NewRequestWithChatID[bool]("editGeneralForumTopic", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
@@ -167,7 +167,7 @@ func (api *API) EditGeneralForumTopicWithContext(ctx context.Context, params Edi
 // CloseGeneralForumTopic closes the 'General' topic in a forum supergroup.
 // Returns True on success.
 // See https://core.telegram.org/bots/api#closegeneralforumtopic
-func (api *API) CloseGeneralForumTopic(params BaseGeneralForumTopicP) (bool, error) {
+func (api *API) CloseGeneralForumTopic(params BaseGeneralForumTopic) (bool, error) {
 	req := NewRequestWithChatID[bool]("closeGeneralForumTopic", params, params.ChatID)
 	return req.Do(api)
 }
@@ -175,7 +175,7 @@ func (api *API) CloseGeneralForumTopic(params BaseGeneralForumTopicP) (bool, err
 // CloseGeneralForumTopicWithContext is the context-aware variant of CloseGeneralForumTopic.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#closegeneralforumtopic
-func (api *API) CloseGeneralForumTopicWithContext(ctx context.Context, params BaseGeneralForumTopicP) (bool, error) {
+func (api *API) CloseGeneralForumTopicWithContext(ctx context.Context, params BaseGeneralForumTopic) (bool, error) {
 	req := NewRequestWithChatID[bool]("closeGeneralForumTopic", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
@@ -183,7 +183,7 @@ func (api *API) CloseGeneralForumTopicWithContext(ctx context.Context, params Ba
 // ReopenGeneralForumTopic reopens the 'General' topic in a forum supergroup.
 // Returns True on success.
 // See https://core.telegram.org/bots/api#reopengeneralforumtopic
-func (api *API) ReopenGeneralForumTopic(params BaseGeneralForumTopicP) (bool, error) {
+func (api *API) ReopenGeneralForumTopic(params BaseGeneralForumTopic) (bool, error) {
 	req := NewRequestWithChatID[bool]("reopenGeneralForumTopic", params, params.ChatID)
 	return req.Do(api)
 }
@@ -191,7 +191,7 @@ func (api *API) ReopenGeneralForumTopic(params BaseGeneralForumTopicP) (bool, er
 // ReopenGeneralForumTopicWithContext is the context-aware variant of ReopenGeneralForumTopic.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#reopengeneralforumtopic
-func (api *API) ReopenGeneralForumTopicWithContext(ctx context.Context, params BaseGeneralForumTopicP) (bool, error) {
+func (api *API) ReopenGeneralForumTopicWithContext(ctx context.Context, params BaseGeneralForumTopic) (bool, error) {
 	req := NewRequestWithChatID[bool]("reopenGeneralForumTopic", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
@@ -199,7 +199,7 @@ func (api *API) ReopenGeneralForumTopicWithContext(ctx context.Context, params B
 // HideGeneralForumTopic hides the 'General' topic in a forum supergroup.
 // Returns True on success.
 // See https://core.telegram.org/bots/api#hidegeneralforumtopic
-func (api *API) HideGeneralForumTopic(params BaseGeneralForumTopicP) (bool, error) {
+func (api *API) HideGeneralForumTopic(params BaseGeneralForumTopic) (bool, error) {
 	req := NewRequestWithChatID[bool]("hideGeneralForumTopic", params, params.ChatID)
 	return req.Do(api)
 }
@@ -207,7 +207,7 @@ func (api *API) HideGeneralForumTopic(params BaseGeneralForumTopicP) (bool, erro
 // HideGeneralForumTopicWithContext is the context-aware variant of HideGeneralForumTopic.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#hidegeneralforumtopic
-func (api *API) HideGeneralForumTopicWithContext(ctx context.Context, params BaseGeneralForumTopicP) (bool, error) {
+func (api *API) HideGeneralForumTopicWithContext(ctx context.Context, params BaseGeneralForumTopic) (bool, error) {
 	req := NewRequestWithChatID[bool]("hideGeneralForumTopic", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
@@ -215,7 +215,7 @@ func (api *API) HideGeneralForumTopicWithContext(ctx context.Context, params Bas
 // UnhideGeneralForumTopic unhides the 'General' topic in a forum supergroup.
 // Returns True on success.
 // See https://core.telegram.org/bots/api#unhidegeneralforumtopic
-func (api *API) UnhideGeneralForumTopic(params BaseGeneralForumTopicP) (bool, error) {
+func (api *API) UnhideGeneralForumTopic(params BaseGeneralForumTopic) (bool, error) {
 	req := NewRequestWithChatID[bool]("unhideGeneralForumTopic", params, params.ChatID)
 	return req.Do(api)
 }
@@ -223,7 +223,7 @@ func (api *API) UnhideGeneralForumTopic(params BaseGeneralForumTopicP) (bool, er
 // UnhideGeneralForumTopicWithContext is the context-aware variant of UnhideGeneralForumTopic.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#unhidegeneralforumtopic
-func (api *API) UnhideGeneralForumTopicWithContext(ctx context.Context, params BaseGeneralForumTopicP) (bool, error) {
+func (api *API) UnhideGeneralForumTopicWithContext(ctx context.Context, params BaseGeneralForumTopic) (bool, error) {
 	req := NewRequestWithChatID[bool]("unhideGeneralForumTopic", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
@@ -231,7 +231,7 @@ func (api *API) UnhideGeneralForumTopicWithContext(ctx context.Context, params B
 // UnpinAllGeneralForumTopicMessages clears the list of pinned messages in the 'General' topic.
 // Returns True on success.
 // See https://core.telegram.org/bots/api#unpinallgeneralforumtopicmessages
-func (api *API) UnpinAllGeneralForumTopicMessages(params BaseGeneralForumTopicP) (bool, error) {
+func (api *API) UnpinAllGeneralForumTopicMessages(params BaseGeneralForumTopic) (bool, error) {
 	req := NewRequestWithChatID[bool]("unpinAllGeneralForumTopicMessages", params, params.ChatID)
 	return req.Do(api)
 }
@@ -239,7 +239,7 @@ func (api *API) UnpinAllGeneralForumTopicMessages(params BaseGeneralForumTopicP)
 // UnpinAllGeneralForumTopicMessagesWithContext is the context-aware variant of UnpinAllGeneralForumTopicMessages.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#unpinallgeneralforumtopicmessages
-func (api *API) UnpinAllGeneralForumTopicMessagesWithContext(ctx context.Context, params BaseGeneralForumTopicP) (bool, error) {
+func (api *API) UnpinAllGeneralForumTopicMessagesWithContext(ctx context.Context, params BaseGeneralForumTopic) (bool, error) {
 	req := NewRequestWithChatID[bool]("unpinAllGeneralForumTopicMessages", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }

tgapi/forum_types.go

@@ -19,3 +19,19 @@ const (
 	// ForumTopicIconColorBlue is the blue color for forum topic icons (value 7322096).
 	ForumTopicIconColorBlue ForumTopicIconColor = 7322096
 )
+
+type ForumTopicCreated struct {
+	Name              string `json:"name"`
+	IconColor         int    `json:"icon_color"`
+	IconCustomEmojiID string `json:"icon_custom_emoji_id,omitempty"`
+	IsNameImplicit    bool   `json:"is_name_implicit,omitempty"`
+}
+type ForumTopicEdited struct {
+	Name              string `json:"name,omitempty"`
+	IconCustomEmojiID string `json:"icon_custom_emoji_id,omitempty"`
+}
+type ForumTopicClosed struct{}
+type ForumTopicReopened struct{}
+type GeneralForumTopicHidden struct{}
+type GeneralForumTopicUnhidden struct {
+}

tgapi/games_methods.go

@@ -2,9 +2,9 @@ package tgapi
 
 import "context"
 
-// SendGameP holds parameters for the sendGame method.
+// SendGame holds parameters for the sendGame method.
 // See https://core.telegram.org/bots/api#sendgame
-type SendGameP struct {
+type SendGame struct {
 	BusinessConnectionID string `json:"business_connection_id,omitempty"`
 	ChatID               int64  `json:"chat_id"`
 	MessageThreadID      int    `json:"message_thread_id,omitempty"`
@@ -21,7 +21,7 @@ type SendGameP struct {
 
 // SendGame sends a game message.
 // See https://core.telegram.org/bots/api#sendgame
-func (api *API) SendGame(params SendGameP) (Message, error) {
+func (api *API) SendGame(params SendGame) (Message, error) {
 	req := NewRequestWithChatID[Message]("sendGame", params, params.ChatID)
 	return req.Do(api)
 }
@@ -29,14 +29,14 @@ func (api *API) SendGame(params SendGameP) (Message, error) {
 // SendGameWithContext is the context-aware variant of SendGame.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#sendgame
-func (api *API) SendGameWithContext(ctx context.Context, params SendGameP) (Message, error) {
+func (api *API) SendGameWithContext(ctx context.Context, params SendGame) (Message, error) {
 	req := NewRequestWithChatID[Message]("sendGame", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
 
-// SetGameScoreP holds parameters for the setGameScore method.
+// SetGameScore holds parameters for the setGameScore method.
 // See https://core.telegram.org/bots/api#setgamescore
-type SetGameScoreP struct {
+type SetGameScore struct {
 	UserID             int64  `json:"user_id"`
 	Score              int    `json:"score"`
 	Force              bool   `json:"force,omitempty"`
@@ -50,7 +50,7 @@ type SetGameScoreP struct {
 // If inline_message_id is provided, returns a boolean success flag.
 // Otherwise returns the edited Message.
 // See https://core.telegram.org/bots/api#setgamescore
-func (api *API) SetGameScore(params SetGameScoreP) (Message, bool, error) {
+func (api *API) SetGameScore(params SetGameScore) (Message, bool, error) {
 	var zero Message
 	if params.InlineMessageID != "" {
 		req := NewRequestWithChatID[bool]("setGameScore", params, params.ChatID)
@@ -65,7 +65,7 @@ func (api *API) SetGameScore(params SetGameScoreP) (Message, bool, error) {
 // SetGameScoreWithContext is the context-aware variant of SetGameScore.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#setgamescore
-func (api *API) SetGameScoreWithContext(ctx context.Context, params SetGameScoreP) (Message, bool, error) {
+func (api *API) SetGameScoreWithContext(ctx context.Context, params SetGameScore) (Message, bool, error) {
 	var zero Message
 	if params.InlineMessageID != "" {
 		req := NewRequestWithChatID[bool]("setGameScore", params, params.ChatID)
@@ -77,9 +77,9 @@ func (api *API) SetGameScoreWithContext(ctx context.Context, params SetGameScore
 	return res, false, err
 }
 
-// GetGameHighScoresP holds parameters for the getGameHighScores method.
+// GetGameHighScores holds parameters for the getGameHighScores method.
 // See https://core.telegram.org/bots/api#getgamehighscores
-type GetGameHighScoresP struct {
+type GetGameHighScores struct {
 	UserID          int64  `json:"user_id"`
 	ChatID          int64  `json:"chat_id,omitempty"`
 	MessageID       int    `json:"message_id,omitempty"`
@@ -88,7 +88,7 @@ type GetGameHighScoresP struct {
 
 // GetGameHighScores returns game high score data for a user.
 // See https://core.telegram.org/bots/api#getgamehighscores
-func (api *API) GetGameHighScores(params GetGameHighScoresP) ([]GameHighScore, error) {
+func (api *API) GetGameHighScores(params GetGameHighScores) ([]GameHighScore, error) {
 	req := NewRequestWithChatID[[]GameHighScore]("getGameHighScores", params, params.ChatID)
 	return req.Do(api)
 }
@@ -96,7 +96,7 @@ func (api *API) GetGameHighScores(params GetGameHighScoresP) ([]GameHighScore, e
 // GetGameHighScoresWithContext is the context-aware variant of GetGameHighScores.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#getgamehighscores
-func (api *API) GetGameHighScoresWithContext(ctx context.Context, params GetGameHighScoresP) ([]GameHighScore, error) {
+func (api *API) GetGameHighScoresWithContext(ctx context.Context, params GetGameHighScores) ([]GameHighScore, error) {
 	req := NewRequestWithChatID[[]GameHighScore]("getGameHighScores", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }

tgapi/games_types.go

@@ -1,5 +1,15 @@
 package tgapi
 
+type Game struct {
+	Title        string          `json:"title"`
+	Description  string          `json:"description"`
+	Photo        []PhotoSize     `json:"photo"`
+	Text         string          `json:"text,omitempty"`
+	TextEntities []MessageEntity `json:"text_entities,omitempty"`
+	Animation    *Animation      `json:"animation,omitempty"`
+}
+type CallbackGame struct{}
+
 // GameHighScore represents one row in a game high score table.
 // See https://core.telegram.org/bots/api#gamehighscore
 type GameHighScore struct {

tgapi/inline_methods.go

@@ -2,9 +2,9 @@ package tgapi
 
 import "context"
 
-// AnswerInlineQueryP holds parameters for the answerInlineQuery method.
+// AnswerInlineQuery holds parameters for the answerInlineQuery method.
 // See https://core.telegram.org/bots/api#answerinlinequery
-type AnswerInlineQueryP struct {
+type AnswerInlineQuery struct {
 	InlineQueryID string                    `json:"inline_query_id"`
 	Results       []InlineQueryResult       `json:"results"`
 	CacheTime     int                       `json:"cache_time,omitempty"`
@@ -16,7 +16,7 @@ type AnswerInlineQueryP struct {
 // AnswerInlineQuery sends answers to an inline query.
 // Returns true on success.
 // See https://core.telegram.org/bots/api#answerinlinequery
-func (api *API) AnswerInlineQuery(params AnswerInlineQueryP) (bool, error) {
+func (api *API) AnswerInlineQuery(params AnswerInlineQuery) (bool, error) {
 	req := NewRequest[bool]("answerInlineQuery", params)
 	return req.Do(api)
 }
@@ -24,21 +24,21 @@ func (api *API) AnswerInlineQuery(params AnswerInlineQueryP) (bool, error) {
 // AnswerInlineQueryWithContext is the context-aware variant of AnswerInlineQuery.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#answerinlinequery
-func (api *API) AnswerInlineQueryWithContext(ctx context.Context, params AnswerInlineQueryP) (bool, error) {
+func (api *API) AnswerInlineQueryWithContext(ctx context.Context, params AnswerInlineQuery) (bool, error) {
 	req := NewRequest[bool]("answerInlineQuery", params)
 	return req.DoWithContext(ctx, api)
 }
 
-// AnswerWebAppQueryP holds parameters for the answerWebAppQuery method.
+// AnswerWebAppQuery holds parameters for the answerWebAppQuery method.
 // See https://core.telegram.org/bots/api#answerwebappquery
-type AnswerWebAppQueryP struct {
+type AnswerWebAppQuery struct {
 	WebAppQueryID string            `json:"web_app_query_id"`
 	Result        InlineQueryResult `json:"result"`
 }
 
 // AnswerWebAppQuery sets the result of a Web App interaction.
 // See https://core.telegram.org/bots/api#answerwebappquery
-func (api *API) AnswerWebAppQuery(params AnswerWebAppQueryP) (SentWebAppMessage, error) {
+func (api *API) AnswerWebAppQuery(params AnswerWebAppQuery) (SentWebAppMessage, error) {
 	req := NewRequest[SentWebAppMessage]("answerWebAppQuery", params)
 	return req.Do(api)
 }
@@ -46,14 +46,14 @@ func (api *API) AnswerWebAppQuery(params AnswerWebAppQueryP) (SentWebAppMessage,
 // AnswerWebAppQueryWithContext is the context-aware variant of AnswerWebAppQuery.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#answerwebappquery
-func (api *API) AnswerWebAppQueryWithContext(ctx context.Context, params AnswerWebAppQueryP) (SentWebAppMessage, error) {
+func (api *API) AnswerWebAppQueryWithContext(ctx context.Context, params AnswerWebAppQuery) (SentWebAppMessage, error) {
 	req := NewRequest[SentWebAppMessage]("answerWebAppQuery", params)
 	return req.DoWithContext(ctx, api)
 }
 
-// SavePreparedInlineMessageP holds parameters for the savePreparedInlineMessage method.
+// SavePreparedInlineMessage holds parameters for the savePreparedInlineMessage method.
 // See https://core.telegram.org/bots/api#savepreparedinlinemessage
-type SavePreparedInlineMessageP struct {
+type SavePreparedInlineMessage struct {
 	UserID            int64             `json:"user_id"`
 	Result            InlineQueryResult `json:"result"`
 	AllowUserChats    bool              `json:"allow_user_chats,omitempty"`
@@ -64,7 +64,7 @@ type SavePreparedInlineMessageP struct {
 
 // SavePreparedInlineMessage stores a prepared message for Mini App users.
 // See https://core.telegram.org/bots/api#savepreparedinlinemessage
-func (api *API) SavePreparedInlineMessage(params SavePreparedInlineMessageP) (PreparedInlineMessage, error) {
+func (api *API) SavePreparedInlineMessage(params SavePreparedInlineMessage) (PreparedInlineMessage, error) {
 	req := NewRequest[PreparedInlineMessage]("savePreparedInlineMessage", params)
 	return req.Do(api)
 }
@@ -72,7 +72,29 @@ func (api *API) SavePreparedInlineMessage(params SavePreparedInlineMessageP) (Pr
 // SavePreparedInlineMessageWithContext is the context-aware variant of SavePreparedInlineMessage.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#savepreparedinlinemessage
-func (api *API) SavePreparedInlineMessageWithContext(ctx context.Context, params SavePreparedInlineMessageP) (PreparedInlineMessage, error) {
+func (api *API) SavePreparedInlineMessageWithContext(ctx context.Context, params SavePreparedInlineMessage) (PreparedInlineMessage, error) {
 	req := NewRequest[PreparedInlineMessage]("savePreparedInlineMessage", params)
 	return req.DoWithContext(ctx, api)
 }
+
+// SavePreparedKeyboardButton holds parameters for the savePreparedKeyboardButton method.
+// See https://core.telegram.org/bots/api#savepreparedkeyboardbutton
+type SavePreparedKeyboardButton struct {
+	UserID int64          `json:"user_id"`
+	Button KeyboardButton `json:"button"`
+}
+
+// SavePreparedKeyboardButton stores a prepared keyboard button for Mini App users.
+// See https://core.telegram.org/bots/api#savepreparedkeyboardbutton
+func (api *API) SavePreparedKeyboardButton(params SavePreparedKeyboardButton) (PreparedKeyboardButton, error) {
+	req := NewRequest[PreparedKeyboardButton]("savePreparedKeyboardButton", params)
+	return req.Do(api)
+}
+
+// SavePreparedKeyboardButtonWithContext is the context-aware variant of SavePreparedKeyboardButton.
+// It executes the same request but uses ctx for cancellation and deadlines.
+// See https://core.telegram.org/bots/api#savepreparedkeyboardbutton
+func (api *API) SavePreparedKeyboardButtonWithContext(ctx context.Context, params SavePreparedKeyboardButton) (PreparedKeyboardButton, error) {
+	req := NewRequest[PreparedKeyboardButton]("savePreparedKeyboardButton", params)
+	return req.DoWithContext(ctx, api)
+}

tgapi/inline_types.go

@@ -24,3 +24,9 @@ type PreparedInlineMessage struct {
 	ID             string `json:"id"`
 	ExpirationDate int    `json:"expiration_date"`
 }
+
+// PreparedKeyboardButton describes a prepared keyboard button.
+// See https://core.telegram.org/bots/api#preparedkeyboardbutton
+type PreparedKeyboardButton struct {
+	ID string `json:"id"`
+}

tgapi/messages_methods.go

@@ -2,9 +2,9 @@ package tgapi
 
 import "context"
 
-// SendMessageP holds parameters for the sendMessage method.
+// SendMessage holds parameters for the sendMessage method.
 // See https://core.telegram.org/bots/api#sendmessage
-type SendMessageP struct {
+type SendMessage struct {
 	BusinessConnectionID  string `json:"business_connection_id,omitempty"`
 	ChatID                int64  `json:"chat_id"`
 	MessageThreadID       int    `json:"message_thread_id,omitempty"`
@@ -26,22 +26,22 @@ type SendMessageP struct {
 
 // SendMessage sends a text message.
 // See https://core.telegram.org/bots/api#sendmessage
-func (api *API) SendMessage(params SendMessageP) (Message, error) {
-	req := NewRequestWithChatID[Message, SendMessageP]("sendMessage", params, params.ChatID)
+func (api *API) SendMessage(params SendMessage) (Message, error) {
+	req := NewRequestWithChatID[Message, SendMessage]("sendMessage", params, params.ChatID)
 	return req.Do(api)
 }
 
 // SendMessageWithContext is the context-aware variant of SendMessage.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#sendmessage
-func (api *API) SendMessageWithContext(ctx context.Context, params SendMessageP) (Message, error) {
-	req := NewRequestWithChatID[Message, SendMessageP]("sendMessage", params, params.ChatID)
+func (api *API) SendMessageWithContext(ctx context.Context, params SendMessage) (Message, error) {
+	req := NewRequestWithChatID[Message, SendMessage]("sendMessage", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
 
-// ForwardMessageP holds parameters for the forwardMessage method.
+// ForwardMessage holds parameters for the forwardMessage method.
 // See https://core.telegram.org/bots/api#forwardmessage
-type ForwardMessageP struct {
+type ForwardMessage struct {
 	ChatID                int64 `json:"chat_id"`
 	MessageThreadID       int   `json:"message_thread_id,omitempty"`
 	DirectMessagesTopicID int   `json:"direct_messages_topic_id,omitempty"`
@@ -58,7 +58,7 @@ type ForwardMessageP struct {
 
 // ForwardMessage forwards a message.
 // See https://core.telegram.org/bots/api#forwardmessage
-func (api *API) ForwardMessage(params ForwardMessageP) (Message, error) {
+func (api *API) ForwardMessage(params ForwardMessage) (Message, error) {
 	req := NewRequestWithChatID[Message]("forwardMessage", params, params.ChatID)
 	return req.Do(api)
 }
@@ -66,14 +66,14 @@ func (api *API) ForwardMessage(params ForwardMessageP) (Message, error) {
 // ForwardMessageWithContext is the context-aware variant of ForwardMessage.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#forwardmessage
-func (api *API) ForwardMessageWithContext(ctx context.Context, params ForwardMessageP) (Message, error) {
+func (api *API) ForwardMessageWithContext(ctx context.Context, params ForwardMessage) (Message, error) {
 	req := NewRequestWithChatID[Message]("forwardMessage", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
 
-// ForwardMessagesP holds parameters for the forwardMessages method.
+// ForwardMessages holds parameters for the forwardMessages method.
 // See https://core.telegram.org/bots/api#forwardmessages
-type ForwardMessagesP struct {
+type ForwardMessages struct {
 	ChatID                int64 `json:"chat_id"`
 	MessageThreadID       int   `json:"message_thread_id,omitempty"`
 	DirectMessagesTopicID int   `json:"direct_messages_topic_id,omitempty"`
@@ -87,7 +87,7 @@ type ForwardMessagesP struct {
 // ForwardMessages forwards multiple messages.
 // Returns an array of message IDs of the sent messages.
 // See https://core.telegram.org/bots/api#forwardmessages
-func (api *API) ForwardMessages(params ForwardMessagesP) ([]MessageID, error) {
+func (api *API) ForwardMessages(params ForwardMessages) ([]MessageID, error) {
 	req := NewRequestWithChatID[[]MessageID]("forwardMessages", params, params.ChatID)
 	return req.Do(api)
 }
@@ -95,14 +95,14 @@ func (api *API) ForwardMessages(params ForwardMessagesP) ([]MessageID, error) {
 // ForwardMessagesWithContext is the context-aware variant of ForwardMessages.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#forwardmessages
-func (api *API) ForwardMessagesWithContext(ctx context.Context, params ForwardMessagesP) ([]MessageID, error) {
+func (api *API) ForwardMessagesWithContext(ctx context.Context, params ForwardMessages) ([]MessageID, error) {
 	req := NewRequestWithChatID[[]MessageID]("forwardMessages", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
 
-// CopyMessageP holds parameters for the copyMessage method.
+// CopyMessage holds parameters for the copyMessage method.
 // See https://core.telegram.org/bots/api#copymessage
-type CopyMessageP struct {
+type CopyMessage struct {
 	ChatID                int64 `json:"chat_id"`
 	MessageThreadID       int   `json:"message_thread_id,omitempty"`
 	DirectMessagesTopicID int   `json:"direct_messages_topic_id,omitempty"`
@@ -128,7 +128,7 @@ type CopyMessageP struct {
 // CopyMessage copies a message.
 // Returns the MessageID of the sent copy.
 // See https://core.telegram.org/bots/api#copymessage
-func (api *API) CopyMessage(params CopyMessageP) (int, error) {
+func (api *API) CopyMessage(params CopyMessage) (int, error) {
 	msgID, err := NewRequestWithChatID[MessageID]("copyMessage", params, params.ChatID).Do(api)
 	if err != nil {
 		return 0, err
@@ -139,7 +139,7 @@ func (api *API) CopyMessage(params CopyMessageP) (int, error) {
 // CopyMessageWithContext is the context-aware variant of CopyMessage.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#copymessage
-func (api *API) CopyMessageWithContext(ctx context.Context, params CopyMessageP) (int, error) {
+func (api *API) CopyMessageWithContext(ctx context.Context, params CopyMessage) (int, error) {
 	msgID, err := NewRequestWithChatID[MessageID]("copyMessage", params, params.ChatID).DoWithContext(ctx, api)
 	if err != nil {
 		return 0, err
@@ -147,9 +147,9 @@ func (api *API) CopyMessageWithContext(ctx context.Context, params CopyMessageP)
 	return msgID.MessageID, nil
 }
 
-// CopyMessagesP holds parameters for the copyMessages method.
+// CopyMessages holds parameters for the copyMessages method.
 // See https://core.telegram.org/bots/api#copymessages
-type CopyMessagesP struct {
+type CopyMessages struct {
 	ChatID                int64 `json:"chat_id"`
 	MessageThreadID       int   `json:"message_thread_id,omitempty"`
 	DirectMessagesTopicID int   `json:"direct_messages_topic_id,omitempty"`
@@ -164,7 +164,7 @@ type CopyMessagesP struct {
 // CopyMessages copies multiple messages.
 // Returns an array of message IDs of the sent copies.
 // See https://core.telegram.org/bots/api#copymessages
-func (api *API) CopyMessages(params CopyMessagesP) ([]MessageID, error) {
+func (api *API) CopyMessages(params CopyMessages) ([]MessageID, error) {
 	req := NewRequestWithChatID[[]MessageID]("copyMessages", params, params.ChatID)
 	return req.Do(api)
 }
@@ -172,14 +172,14 @@ func (api *API) CopyMessages(params CopyMessagesP) ([]MessageID, error) {
 // CopyMessagesWithContext is the context-aware variant of CopyMessages.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#copymessages
-func (api *API) CopyMessagesWithContext(ctx context.Context, params CopyMessagesP) ([]MessageID, error) {
+func (api *API) CopyMessagesWithContext(ctx context.Context, params CopyMessages) ([]MessageID, error) {
 	req := NewRequestWithChatID[[]MessageID]("copyMessages", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
 
-// SendLocationP holds parameters for the sendLocation method.
+// SendLocation holds parameters for the sendLocation method.
 // See https://core.telegram.org/bots/api#sendlocation
-type SendLocationP struct {
+type SendLocation struct {
 	BusinessConnectionID  string `json:"business_connection_id,omitempty"`
 	ChatID                int64  `json:"chat_id"`
 	MessageThreadID       int    `json:"message_thread_id,omitempty"`
@@ -204,7 +204,7 @@ type SendLocationP struct {
 
 // SendLocation sends a point on the map.
 // See https://core.telegram.org/bots/api#sendlocation
-func (api *API) SendLocation(params SendLocationP) (Message, error) {
+func (api *API) SendLocation(params SendLocation) (Message, error) {
 	req := NewRequestWithChatID[Message]("sendLocation", params, params.ChatID)
 	return req.Do(api)
 }
@@ -212,14 +212,14 @@ func (api *API) SendLocation(params SendLocationP) (Message, error) {
 // SendLocationWithContext is the context-aware variant of SendLocation.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#sendlocation
-func (api *API) SendLocationWithContext(ctx context.Context, params SendLocationP) (Message, error) {
+func (api *API) SendLocationWithContext(ctx context.Context, params SendLocation) (Message, error) {
 	req := NewRequestWithChatID[Message]("sendLocation", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
 
-// SendVenueP holds parameters for the sendVenue method.
+// SendVenue holds parameters for the sendVenue method.
 // See https://core.telegram.org/bots/api#sendvenue
-type SendVenueP struct {
+type SendVenue struct {
 	BusinessConnectionID  string `json:"business_connection_id,omitempty"`
 	ChatID                int64  `json:"chat_id"`
 	MessageThreadID       int    `json:"message_thread_id,omitempty"`
@@ -246,7 +246,7 @@ type SendVenueP struct {
 
 // SendVenue sends information about a venue.
 // See https://core.telegram.org/bots/api#sendvenue
-func (api *API) SendVenue(params SendVenueP) (Message, error) {
+func (api *API) SendVenue(params SendVenue) (Message, error) {
 	req := NewRequestWithChatID[Message]("sendVenue", params, params.ChatID)
 	return req.Do(api)
 }
@@ -254,14 +254,14 @@ func (api *API) SendVenue(params SendVenueP) (Message, error) {
 // SendVenueWithContext is the context-aware variant of SendVenue.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#sendvenue
-func (api *API) SendVenueWithContext(ctx context.Context, params SendVenueP) (Message, error) {
+func (api *API) SendVenueWithContext(ctx context.Context, params SendVenue) (Message, error) {
 	req := NewRequestWithChatID[Message]("sendVenue", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
 
-// SendContactP holds parameters for the sendContact method.
+// SendContact holds parameters for the sendContact method.
 // See https://core.telegram.org/bots/api#sendcontact
-type SendContactP struct {
+type SendContact struct {
 	BusinessConnectionID  string `json:"business_connection_id,omitempty"`
 	ChatID                int64  `json:"chat_id"`
 	MessageThreadID       int    `json:"message_thread_id,omitempty"`
@@ -284,7 +284,7 @@ type SendContactP struct {
 
 // SendContact sends a phone contact.
 // See https://core.telegram.org/bots/api#sendcontact
-func (api *API) SendContact(params SendContactP) (Message, error) {
+func (api *API) SendContact(params SendContact) (Message, error) {
 	req := NewRequestWithChatID[Message]("sendContact", params, params.ChatID)
 	return req.Do(api)
 }
@@ -292,32 +292,40 @@ func (api *API) SendContact(params SendContactP) (Message, error) {
 // SendContactWithContext is the context-aware variant of SendContact.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#sendcontact
-func (api *API) SendContactWithContext(ctx context.Context, params SendContactP) (Message, error) {
+func (api *API) SendContactWithContext(ctx context.Context, params SendContact) (Message, error) {
 	req := NewRequestWithChatID[Message]("sendContact", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
 
-// SendPollP holds parameters for the sendPoll method.
+// SendPoll holds parameters for the sendPoll method.
 // See https://core.telegram.org/bots/api#sendpoll
-type SendPollP struct {
+type SendPoll struct {
 	BusinessConnectionID string `json:"business_connection_id,omitempty"`
 	ChatID               int64  `json:"chat_id"`
 	MessageThreadID      int    `json:"message_thread_id,omitempty"`
 
-	Question              string            `json:"question"`
-	QuestionParseMode     ParseMode         `json:"question_parse_mode,omitempty"`
-	QuestionEntities      []MessageEntity   `json:"question_entities,omitempty"`
-	Options               []InputPollOption `json:"options"`
-	IsAnonymous           bool              `json:"is_anonymous,omitempty"`
-	Type                  PollType          `json:"type"`
-	AllowsMultipleAnswers bool              `json:"allows_multiple_answers,omitempty"`
-	CorrectOptionID       int               `json:"correct_option_id,omitempty"`
-	Explanation           string            `json:"explanation,omitempty"`
-	ExplanationParseMode  ParseMode         `json:"explanation_parse_mode,omitempty"`
-	ExplanationEntities   []MessageEntity   `json:"explanation_entities,omitempty"`
-	OpenPeriod            int               `json:"open_period,omitempty"`
-	CloseDate             int               `json:"close_date"`
-	IsClosed              bool              `json:"is_closed,omitempty"`
+	Question               string            `json:"question"`
+	QuestionParseMode      ParseMode         `json:"question_parse_mode,omitempty"`
+	QuestionEntities       []MessageEntity   `json:"question_entities,omitempty"`
+	Options                []InputPollOption `json:"options"`
+	IsAnonymous            bool              `json:"is_anonymous,omitempty"`
+	Type                   PollType          `json:"type"`
+	AllowsMultipleAnswers  bool              `json:"allows_multiple_answers,omitempty"`
+	AllowsRevoting         bool              `json:"allows_revoting,omitempty"`
+	ShuffleOptions         bool              `json:"shuffle_options,omitempty"`
+	AllowAddingOptions     bool              `json:"allow_adding_options,omitempty"`
+	HideResultsUntilCloses bool              `json:"hide_results_until_closes,omitempty"`
+	CorrectOptionIDs       []int             `json:"correct_option_ids,omitempty"`
+	Explanation            string            `json:"explanation,omitempty"`
+	ExplanationParseMode   ParseMode         `json:"explanation_parse_mode,omitempty"`
+	ExplanationEntities    []MessageEntity   `json:"explanation_entities,omitempty"`
+	OpenPeriod             int               `json:"open_period,omitempty"`
+	CloseDate              int               `json:"close_date"`
+	IsClosed               bool              `json:"is_closed,omitempty"`
+
+	Description          string          `json:"description"`
+	DescriptionParseMode ParseMode       `json:"description_parse_mode,omitempty"`
+	DescriptionEntities  []MessageEntity `json:"description_entities,omitempty"`
 
 	DisableNotification bool   `json:"disable_notification,omitempty"`
 	ProtectContent      bool   `json:"protect_content,omitempty"`
@@ -330,7 +338,7 @@ type SendPollP struct {
 
 // SendPoll sends a native poll.
 // See https://core.telegram.org/bots/api#sendpoll
-func (api *API) SendPoll(params SendPollP) (Message, error) {
+func (api *API) SendPoll(params SendPoll) (Message, error) {
 	req := NewRequestWithChatID[Message]("sendPoll", params, params.ChatID)
 	return req.Do(api)
 }
@@ -338,14 +346,14 @@ func (api *API) SendPoll(params SendPollP) (Message, error) {
 // SendPollWithContext is the context-aware variant of SendPoll.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#sendpoll
-func (api *API) SendPollWithContext(ctx context.Context, params SendPollP) (Message, error) {
+func (api *API) SendPollWithContext(ctx context.Context, params SendPoll) (Message, error) {
 	req := NewRequestWithChatID[Message]("sendPoll", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
 
-// SendChecklistP holds parameters for the sendChecklist method.
+// SendChecklist holds parameters for the sendChecklist method.
 // See https://core.telegram.org/bots/api#sendchecklist
-type SendChecklistP struct {
+type SendChecklist struct {
 	BusinessConnectionID string         `json:"business_connection_id"`
 	ChatID               int64          `json:"chat_id"`
 	Checklist            InputChecklist `json:"checklist"`
@@ -360,7 +368,7 @@ type SendChecklistP struct {
 
 // SendChecklist sends a checklist.
 // See https://core.telegram.org/bots/api#sendchecklist
-func (api *API) SendChecklist(params SendChecklistP) (Message, error) {
+func (api *API) SendChecklist(params SendChecklist) (Message, error) {
 	req := NewRequestWithChatID[Message]("sendChecklist", params, params.ChatID)
 	return req.Do(api)
 }
@@ -368,14 +376,14 @@ func (api *API) SendChecklist(params SendChecklistP) (Message, error) {
 // SendChecklistWithContext is the context-aware variant of SendChecklist.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#sendchecklist
-func (api *API) SendChecklistWithContext(ctx context.Context, params SendChecklistP) (Message, error) {
+func (api *API) SendChecklistWithContext(ctx context.Context, params SendChecklist) (Message, error) {
 	req := NewRequestWithChatID[Message]("sendChecklist", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
 
-// SendDiceP holds parameters for the sendDice method.
+// SendDice holds parameters for the sendDice method.
 // See https://core.telegram.org/bots/api#senddice
-type SendDiceP struct {
+type SendDice struct {
 	BusinessConnectionID  string `json:"business_connection_id,omitempty"`
 	ChatID                int64  `json:"chat_id"`
 	MessageThreadID       int    `json:"message_thread_id,omitempty"`
@@ -395,7 +403,7 @@ type SendDiceP struct {
 
 // SendDice sends a dice, which will have a random value.
 // See https://core.telegram.org/bots/api#senddice
-func (api *API) SendDice(params SendDiceP) (Message, error) {
+func (api *API) SendDice(params SendDice) (Message, error) {
 	req := NewRequestWithChatID[Message]("sendDice", params, params.ChatID)
 	return req.Do(api)
 }
@@ -403,14 +411,14 @@ func (api *API) SendDice(params SendDiceP) (Message, error) {
 // SendDiceWithContext is the context-aware variant of SendDice.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#senddice
-func (api *API) SendDiceWithContext(ctx context.Context, params SendDiceP) (Message, error) {
+func (api *API) SendDiceWithContext(ctx context.Context, params SendDice) (Message, error) {
 	req := NewRequestWithChatID[Message]("sendDice", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
 
-// SendMessageDraftP holds parameters for the sendMessageDraft method.
+// SendMessageDraft holds parameters for the sendMessageDraft method.
 // See https://core.telegram.org/bots/api#sendmessagedraft
-type SendMessageDraftP struct {
+type SendMessageDraft struct {
 	ChatID          int64           `json:"chat_id"`
 	MessageThreadID int             `json:"message_thread_id,omitempty"`
 	DraftID         uint64          `json:"draft_id"`
@@ -422,7 +430,7 @@ type SendMessageDraftP struct {
 // SendMessageDraft sends or updates a draft message in the target chat.
 // Returns True on success.
 // See https://core.telegram.org/bots/api#sendmessagedraft
-func (api *API) SendMessageDraft(params SendMessageDraftP) (bool, error) {
+func (api *API) SendMessageDraft(params SendMessageDraft) (bool, error) {
 	req := NewRequestWithChatID[bool]("sendMessageDraft", params, params.ChatID)
 	return req.Do(api)
 }
@@ -430,14 +438,14 @@ func (api *API) SendMessageDraft(params SendMessageDraftP) (bool, error) {
 // SendMessageDraftWithContext is the context-aware variant of SendMessageDraft.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#sendmessagedraft
-func (api *API) SendMessageDraftWithContext(ctx context.Context, params SendMessageDraftP) (bool, error) {
+func (api *API) SendMessageDraftWithContext(ctx context.Context, params SendMessageDraft) (bool, error) {
 	req := NewRequestWithChatID[bool]("sendMessageDraft", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
 
-// SendChatActionP holds parameters for the sendChatAction method.
+// SendChatAction holds parameters for the sendChatAction method.
 // See https://core.telegram.org/bots/api#sendchataction
-type SendChatActionP struct {
+type SendChatAction struct {
 	BusinessConnectionID string         `json:"business_connection_id,omitempty"`
 	ChatID               int64          `json:"chat_id"`
 	MessageThreadID      int            `json:"message_thread_id,omitempty"`
@@ -447,7 +455,7 @@ type SendChatActionP struct {
 // SendChatAction sends a chat action (typing, uploading photo, etc.).
 // Returns True on success.
 // See https://core.telegram.org/bots/api#sendchataction
-func (api *API) SendChatAction(params SendChatActionP) (bool, error) {
+func (api *API) SendChatAction(params SendChatAction) (bool, error) {
 	req := NewRequestWithChatID[bool]("sendChatAction", params, params.ChatID)
 	return req.Do(api)
 }
@@ -455,14 +463,14 @@ func (api *API) SendChatAction(params SendChatActionP) (bool, error) {
 // SendChatActionWithContext is the context-aware variant of SendChatAction.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#sendchataction
-func (api *API) SendChatActionWithContext(ctx context.Context, params SendChatActionP) (bool, error) {
+func (api *API) SendChatActionWithContext(ctx context.Context, params SendChatAction) (bool, error) {
 	req := NewRequestWithChatID[bool]("sendChatAction", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
 
-// SetMessageReactionP holds parameters for the setMessageReaction method.
+// SetMessageReaction holds parameters for the setMessageReaction method.
 // See https://core.telegram.org/bots/api#setmessagereaction
-type SetMessageReactionP struct {
+type SetMessageReaction struct {
 	ChatID    int64          `json:"chat_id"`
 	MessageId int            `json:"message_id"`
 	Reaction  []ReactionType `json:"reaction"`
@@ -472,7 +480,7 @@ type SetMessageReactionP struct {
 // SetMessageReaction changes the chosen reaction on a message.
 // Returns True on success.
 // See https://core.telegram.org/bots/api#setmessagereaction
-func (api *API) SetMessageReaction(params SetMessageReactionP) (bool, error) {
+func (api *API) SetMessageReaction(params SetMessageReaction) (bool, error) {
 	req := NewRequestWithChatID[bool]("setMessageReaction", params, params.ChatID)
 	return req.Do(api)
 }
@@ -480,14 +488,14 @@ func (api *API) SetMessageReaction(params SetMessageReactionP) (bool, error) {
 // SetMessageReactionWithContext is the context-aware variant of SetMessageReaction.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#setmessagereaction
-func (api *API) SetMessageReactionWithContext(ctx context.Context, params SetMessageReactionP) (bool, error) {
+func (api *API) SetMessageReactionWithContext(ctx context.Context, params SetMessageReaction) (bool, error) {
 	req := NewRequestWithChatID[bool]("setMessageReaction", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
 
-// EditMessageTextP holds parameters for the editMessageText method.
+// EditMessageText holds parameters for the editMessageText method.
 // See https://core.telegram.org/bots/api#editmessagetext
-type EditMessageTextP struct {
+type EditMessageText struct {
 	BusinessConnectionID string              `json:"business_connection_id,omitempty"`
 	ChatID               int64               `json:"chat_id,omitempty"`
 	MessageID            int                 `json:"message_id,omitempty"`
@@ -503,7 +511,7 @@ type EditMessageTextP struct {
 // If inline_message_id is provided, returns a boolean success flag;
 // otherwise returns the edited Message.
 // See https://core.telegram.org/bots/api#editmessagetext
-func (api *API) EditMessageText(params EditMessageTextP) (Message, bool, error) {
+func (api *API) EditMessageText(params EditMessageText) (Message, bool, error) {
 	var zero Message
 	if params.InlineMessageID != "" {
 		req := NewRequestWithChatID[bool]("editMessageText", params, params.ChatID)
@@ -518,7 +526,7 @@ func (api *API) EditMessageText(params EditMessageTextP) (Message, bool, error)
 // EditMessageTextWithContext is the context-aware variant of EditMessageText.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#editmessagetext
-func (api *API) EditMessageTextWithContext(ctx context.Context, params EditMessageTextP) (Message, bool, error) {
+func (api *API) EditMessageTextWithContext(ctx context.Context, params EditMessageText) (Message, bool, error) {
 	var zero Message
 	if params.InlineMessageID != "" {
 		req := NewRequestWithChatID[bool]("editMessageText", params, params.ChatID)
@@ -530,9 +538,9 @@ func (api *API) EditMessageTextWithContext(ctx context.Context, params EditMessa
 	return res, false, err
 }
 
-// EditMessageCaptionP holds parameters for the editMessageCaption method.
+// EditMessageCaption holds parameters for the editMessageCaption method.
 // See https://core.telegram.org/bots/api#editmessagecaption
-type EditMessageCaptionP struct {
+type EditMessageCaption struct {
 	BusinessConnectionID  string          `json:"business_connection_id,omitempty"`
 	ChatID                int64           `json:"chat_id,omitempty"`
 	MessageID             int             `json:"message_id,omitempty"`
@@ -548,7 +556,7 @@ type EditMessageCaptionP struct {
 // If inline_message_id is provided, returns a boolean success flag;
 // otherwise returns the edited Message.
 // See https://core.telegram.org/bots/api#editmessagecaption
-func (api *API) EditMessageCaption(params EditMessageCaptionP) (Message, bool, error) {
+func (api *API) EditMessageCaption(params EditMessageCaption) (Message, bool, error) {
 	var zero Message
 	if params.InlineMessageID != "" {
 		req := NewRequestWithChatID[bool]("editMessageCaption", params, params.ChatID)
@@ -563,7 +571,7 @@ func (api *API) EditMessageCaption(params EditMessageCaptionP) (Message, bool, e
 // EditMessageCaptionWithContext is the context-aware variant of EditMessageCaption.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#editmessagecaption
-func (api *API) EditMessageCaptionWithContext(ctx context.Context, params EditMessageCaptionP) (Message, bool, error) {
+func (api *API) EditMessageCaptionWithContext(ctx context.Context, params EditMessageCaption) (Message, bool, error) {
 	var zero Message
 	if params.InlineMessageID != "" {
 		req := NewRequestWithChatID[bool]("editMessageCaption", params, params.ChatID)
@@ -575,9 +583,9 @@ func (api *API) EditMessageCaptionWithContext(ctx context.Context, params EditMe
 	return res, false, err
 }
 
-// EditMessageMediaP holds parameters for the editMessageMedia method.
+// EditMessageMedia holds parameters for the editMessageMedia method.
 // See https://core.telegram.org/bots/api#editmessagemedia
-type EditMessageMediaP struct {
+type EditMessageMedia struct {
 	BusinessConnectionID string                `json:"business_connection_id,omitempty"`
 	ChatID               int64                 `json:"chat_id,omitempty"`
 	MessageID            int                   `json:"message_id,omitempty"`
@@ -590,7 +598,7 @@ type EditMessageMediaP struct {
 // If inline_message_id is provided, returns a boolean success flag;
 // otherwise returns the edited Message.
 // See https://core.telegram.org/bots/api#editmessagemedia
-func (api *API) EditMessageMedia(params EditMessageMediaP) (Message, bool, error) {
+func (api *API) EditMessageMedia(params EditMessageMedia) (Message, bool, error) {
 	var zero Message
 	if params.InlineMessageID != "" {
 		req := NewRequestWithChatID[bool]("editMessageMedia", params, params.ChatID)
@@ -605,7 +613,7 @@ func (api *API) EditMessageMedia(params EditMessageMediaP) (Message, bool, error
 // EditMessageMediaWithContext is the context-aware variant of EditMessageMedia.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#editmessagemedia
-func (api *API) EditMessageMediaWithContext(ctx context.Context, params EditMessageMediaP) (Message, bool, error) {
+func (api *API) EditMessageMediaWithContext(ctx context.Context, params EditMessageMedia) (Message, bool, error) {
 	var zero Message
 	if params.InlineMessageID != "" {
 		req := NewRequestWithChatID[bool]("editMessageMedia", params, params.ChatID)
@@ -617,9 +625,9 @@ func (api *API) EditMessageMediaWithContext(ctx context.Context, params EditMess
 	return res, false, err
 }
 
-// EditMessageLiveLocationP holds parameters for the editMessageLiveLocation method.
+// EditMessageLiveLocation holds parameters for the editMessageLiveLocation method.
 // See https://core.telegram.org/bots/api#editmessagelivelocation
-type EditMessageLiveLocationP struct {
+type EditMessageLiveLocation struct {
 	BusinessConnectionID string `json:"business_connection_id,omitempty"`
 	ChatID               int64  `json:"chat_id,omitempty"`
 	MessageID            int    `json:"message_id,omitempty"`
@@ -638,7 +646,7 @@ type EditMessageLiveLocationP struct {
 // If inline_message_id is provided, returns a boolean success flag;
 // otherwise returns the edited Message.
 // See https://core.telegram.org/bots/api#editmessagelivelocation
-func (api *API) EditMessageLiveLocation(params EditMessageLiveLocationP) (Message, bool, error) {
+func (api *API) EditMessageLiveLocation(params EditMessageLiveLocation) (Message, bool, error) {
 	var zero Message
 	if params.InlineMessageID != "" {
 		req := NewRequestWithChatID[bool]("editMessageLiveLocation", params, params.ChatID)
@@ -653,7 +661,7 @@ func (api *API) EditMessageLiveLocation(params EditMessageLiveLocationP) (Messag
 // EditMessageLiveLocationWithContext is the context-aware variant of EditMessageLiveLocation.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#editmessagelivelocation
-func (api *API) EditMessageLiveLocationWithContext(ctx context.Context, params EditMessageLiveLocationP) (Message, bool, error) {
+func (api *API) EditMessageLiveLocationWithContext(ctx context.Context, params EditMessageLiveLocation) (Message, bool, error) {
 	var zero Message
 	if params.InlineMessageID != "" {
 		req := NewRequestWithChatID[bool]("editMessageLiveLocation", params, params.ChatID)
@@ -665,9 +673,9 @@ func (api *API) EditMessageLiveLocationWithContext(ctx context.Context, params E
 	return res, false, err
 }
 
-// StopMessageLiveLocationP holds parameters for the stopMessageLiveLocation method.
+// StopMessageLiveLocation holds parameters for the stopMessageLiveLocation method.
 // See https://core.telegram.org/bots/api#stopmessagelivelocation
-type StopMessageLiveLocationP struct {
+type StopMessageLiveLocation struct {
 	BusinessConnectionID string                `json:"business_connection_id,omitempty"`
 	ChatID               int64                 `json:"chat_id,omitempty"`
 	MessageID            int                   `json:"message_id,omitempty"`
@@ -679,7 +687,7 @@ type StopMessageLiveLocationP struct {
 // If inline_message_id is provided, returns a boolean success flag;
 // otherwise returns the edited Message.
 // See https://core.telegram.org/bots/api#stopmessagelivelocation
-func (api *API) StopMessageLiveLocation(params StopMessageLiveLocationP) (Message, bool, error) {
+func (api *API) StopMessageLiveLocation(params StopMessageLiveLocation) (Message, bool, error) {
 	var zero Message
 	if params.InlineMessageID != "" {
 		req := NewRequestWithChatID[bool]("stopMessageLiveLocation", params, params.ChatID)
@@ -694,7 +702,7 @@ func (api *API) StopMessageLiveLocation(params StopMessageLiveLocationP) (Messag
 // StopMessageLiveLocationWithContext is the context-aware variant of StopMessageLiveLocation.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#stopmessagelivelocation
-func (api *API) StopMessageLiveLocationWithContext(ctx context.Context, params StopMessageLiveLocationP) (Message, bool, error) {
+func (api *API) StopMessageLiveLocationWithContext(ctx context.Context, params StopMessageLiveLocation) (Message, bool, error) {
 	var zero Message
 	if params.InlineMessageID != "" {
 		req := NewRequestWithChatID[bool]("stopMessageLiveLocation", params, params.ChatID)
@@ -706,8 +714,8 @@ func (api *API) StopMessageLiveLocationWithContext(ctx context.Context, params S
 	return res, false, err
 }
 
-// EditMessageChecklistP holds parameters for the editMessageChecklist method.
-type EditMessageChecklistP struct {
+// EditMessageChecklist holds parameters for the editMessageChecklist method.
+type EditMessageChecklist struct {
 	BusinessConnectionID string                `json:"business_connection_id"`
 	ChatID               int64                 `json:"chat_id"`
 	MessageID            int                   `json:"message_id"`
@@ -717,7 +725,7 @@ type EditMessageChecklistP struct {
 
 // EditMessageChecklist edits a checklist message.
 // See https://core.telegram.org/bots/api#editmessagechecklist
-func (api *API) EditMessageChecklist(params EditMessageChecklistP) (Message, error) {
+func (api *API) EditMessageChecklist(params EditMessageChecklist) (Message, error) {
 	req := NewRequestWithChatID[Message]("editMessageChecklist", params, params.ChatID)
 	return req.Do(api)
 }
@@ -725,14 +733,14 @@ func (api *API) EditMessageChecklist(params EditMessageChecklistP) (Message, err
 // EditMessageChecklistWithContext is the context-aware variant of EditMessageChecklist.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#editmessagechecklist
-func (api *API) EditMessageChecklistWithContext(ctx context.Context, params EditMessageChecklistP) (Message, error) {
+func (api *API) EditMessageChecklistWithContext(ctx context.Context, params EditMessageChecklist) (Message, error) {
 	req := NewRequestWithChatID[Message]("editMessageChecklist", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
 
-// EditMessageReplyMarkupP holds parameters for the editMessageReplyMarkup method.
+// EditMessageReplyMarkup holds parameters for the editMessageReplyMarkup method.
 // See https://core.telegram.org/bots/api#editmessagereplymarkup
-type EditMessageReplyMarkupP struct {
+type EditMessageReplyMarkup struct {
 	BusinessConnectionID string                `json:"business_connection_id,omitempty"`
 	ChatID               int64                 `json:"chat_id,omitempty"`
 	MessageID            int                   `json:"message_id,omitempty"`
@@ -744,7 +752,7 @@ type EditMessageReplyMarkupP struct {
 // If inline_message_id is provided, returns a boolean success flag;
 // otherwise returns the edited Message.
 // See https://core.telegram.org/bots/api#editmessagereplymarkup
-func (api *API) EditMessageReplyMarkup(params EditMessageReplyMarkupP) (Message, bool, error) {
+func (api *API) EditMessageReplyMarkup(params EditMessageReplyMarkup) (Message, bool, error) {
 	var zero Message
 	if params.InlineMessageID != "" {
 		req := NewRequestWithChatID[bool]("editMessageReplyMarkup", params, params.ChatID)
@@ -759,7 +767,7 @@ func (api *API) EditMessageReplyMarkup(params EditMessageReplyMarkupP) (Message,
 // EditMessageReplyMarkupWithContext is the context-aware variant of EditMessageReplyMarkup.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#editmessagereplymarkup
-func (api *API) EditMessageReplyMarkupWithContext(ctx context.Context, params EditMessageReplyMarkupP) (Message, bool, error) {
+func (api *API) EditMessageReplyMarkupWithContext(ctx context.Context, params EditMessageReplyMarkup) (Message, bool, error) {
 	var zero Message
 	if params.InlineMessageID != "" {
 		req := NewRequestWithChatID[bool]("editMessageReplyMarkup", params, params.ChatID)
@@ -771,9 +779,9 @@ func (api *API) EditMessageReplyMarkupWithContext(ctx context.Context, params Ed
 	return res, false, err
 }
 
-// StopPollP holds parameters for the stopPoll method.
+// StopPoll holds parameters for the stopPoll method.
 // See https://core.telegram.org/bots/api#stoppoll
-type StopPollP struct {
+type StopPoll struct {
 	BusinessConnectionID string                `json:"business_connection_id,omitempty"`
 	ChatID               int64                 `json:"chat_id"`
 	MessageID            int                   `json:"message_id"`
@@ -783,7 +791,7 @@ type StopPollP struct {
 // StopPoll stops a poll that was sent by the bot.
 // Returns the stopped Poll.
 // See https://core.telegram.org/bots/api#stoppoll
-func (api *API) StopPoll(params StopPollP) (Poll, error) {
+func (api *API) StopPoll(params StopPoll) (Poll, error) {
 	req := NewRequestWithChatID[Poll]("stopPoll", params, params.ChatID)
 	return req.Do(api)
 }
@@ -791,14 +799,14 @@ func (api *API) StopPoll(params StopPollP) (Poll, error) {
 // StopPollWithContext is the context-aware variant of StopPoll.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#stoppoll
-func (api *API) StopPollWithContext(ctx context.Context, params StopPollP) (Poll, error) {
+func (api *API) StopPollWithContext(ctx context.Context, params StopPoll) (Poll, error) {
 	req := NewRequestWithChatID[Poll]("stopPoll", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
 
-// ApproveSuggestedPostP holds parameters for the approveSuggestedPost method.
+// ApproveSuggestedPost holds parameters for the approveSuggestedPost method.
 // See https://core.telegram.org/bots/api#approvesuggestedpost
-type ApproveSuggestedPostP struct {
+type ApproveSuggestedPost struct {
 	ChatID    int64 `json:"chat_id"`
 	MessageID int   `json:"message_id"`
 	SendDate  int   `json:"send_date,omitempty"`
@@ -807,7 +815,7 @@ type ApproveSuggestedPostP struct {
 // ApproveSuggestedPost approves a suggested channel post.
 // Returns True on success.
 // See https://core.telegram.org/bots/api#approvesuggestedpost
-func (api *API) ApproveSuggestedPost(params ApproveSuggestedPostP) (bool, error) {
+func (api *API) ApproveSuggestedPost(params ApproveSuggestedPost) (bool, error) {
 	req := NewRequestWithChatID[bool]("approveSuggestedPost", params, params.ChatID)
 	return req.Do(api)
 }
@@ -815,14 +823,14 @@ func (api *API) ApproveSuggestedPost(params ApproveSuggestedPostP) (bool, error)
 // ApproveSuggestedPostWithContext is the context-aware variant of ApproveSuggestedPost.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#approvesuggestedpost
-func (api *API) ApproveSuggestedPostWithContext(ctx context.Context, params ApproveSuggestedPostP) (bool, error) {
+func (api *API) ApproveSuggestedPostWithContext(ctx context.Context, params ApproveSuggestedPost) (bool, error) {
 	req := NewRequestWithChatID[bool]("approveSuggestedPost", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
 
-// DeclineSuggestedPostP holds parameters for the declineSuggestedPost method.
+// DeclineSuggestedPost holds parameters for the declineSuggestedPost method.
 // See https://core.telegram.org/bots/api#declinesuggestedpost
-type DeclineSuggestedPostP struct {
+type DeclineSuggestedPost struct {
 	ChatID    int64  `json:"chat_id"`
 	MessageID int    `json:"message_id"`
 	Comment   string `json:"comment,omitempty"`
@@ -831,7 +839,7 @@ type DeclineSuggestedPostP struct {
 // DeclineSuggestedPost declines a suggested channel post.
 // Returns True on success.
 // See https://core.telegram.org/bots/api#declinesuggestedpost
-func (api *API) DeclineSuggestedPost(params DeclineSuggestedPostP) (bool, error) {
+func (api *API) DeclineSuggestedPost(params DeclineSuggestedPost) (bool, error) {
 	req := NewRequestWithChatID[bool]("declineSuggestedPost", params, params.ChatID)
 	return req.Do(api)
 }
@@ -839,14 +847,14 @@ func (api *API) DeclineSuggestedPost(params DeclineSuggestedPostP) (bool, error)
 // DeclineSuggestedPostWithContext is the context-aware variant of DeclineSuggestedPost.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#declinesuggestedpost
-func (api *API) DeclineSuggestedPostWithContext(ctx context.Context, params DeclineSuggestedPostP) (bool, error) {
+func (api *API) DeclineSuggestedPostWithContext(ctx context.Context, params DeclineSuggestedPost) (bool, error) {
 	req := NewRequestWithChatID[bool]("declineSuggestedPost", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
 
-// DeleteMessageP holds parameters for the deleteMessage method.
+// DeleteMessage holds parameters for the deleteMessage method.
 // See https://core.telegram.org/bots/api#deletemessage
-type DeleteMessageP struct {
+type DeleteMessage struct {
 	ChatID    int64 `json:"chat_id"`
 	MessageID int   `json:"message_id"`
 }
@@ -854,7 +862,7 @@ type DeleteMessageP struct {
 // DeleteMessage deletes a message.
 // Returns True on success.
 // See https://core.telegram.org/bots/api#deletemessage
-func (api *API) DeleteMessage(params DeleteMessageP) (bool, error) {
+func (api *API) DeleteMessage(params DeleteMessage) (bool, error) {
 	req := NewRequestWithChatID[bool]("deleteMessage", params, params.ChatID)
 	return req.Do(api)
 }
@@ -862,14 +870,14 @@ func (api *API) DeleteMessage(params DeleteMessageP) (bool, error) {
 // DeleteMessageWithContext is the context-aware variant of DeleteMessage.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#deletemessage
-func (api *API) DeleteMessageWithContext(ctx context.Context, params DeleteMessageP) (bool, error) {
+func (api *API) DeleteMessageWithContext(ctx context.Context, params DeleteMessage) (bool, error) {
 	req := NewRequestWithChatID[bool]("deleteMessage", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
 
-// DeleteMessagesP holds parameters for the deleteMessages method.
+// DeleteMessages holds parameters for the deleteMessages method.
 // See https://core.telegram.org/bots/api#deletemessages
-type DeleteMessagesP struct {
+type DeleteMessages struct {
 	ChatID     int64 `json:"chat_id"`
 	MessageIDs []int `json:"message_ids"`
 }
@@ -877,7 +885,7 @@ type DeleteMessagesP struct {
 // DeleteMessages deletes multiple messages at once.
 // Returns True on success.
 // See https://core.telegram.org/bots/api#deletemessages
-func (api *API) DeleteMessages(params DeleteMessagesP) (bool, error) {
+func (api *API) DeleteMessages(params DeleteMessages) (bool, error) {
 	req := NewRequestWithChatID[bool]("deleteMessages", params, params.ChatID)
 	return req.Do(api)
 }
@@ -885,14 +893,14 @@ func (api *API) DeleteMessages(params DeleteMessagesP) (bool, error) {
 // DeleteMessagesWithContext is the context-aware variant of DeleteMessages.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#deletemessages
-func (api *API) DeleteMessagesWithContext(ctx context.Context, params DeleteMessagesP) (bool, error) {
+func (api *API) DeleteMessagesWithContext(ctx context.Context, params DeleteMessages) (bool, error) {
 	req := NewRequestWithChatID[bool]("deleteMessages", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
 
-// AnswerCallbackQueryP holds parameters for the answerCallbackQuery method.
+// AnswerCallbackQuery holds parameters for the answerCallbackQuery method.
 // See https://core.telegram.org/bots/api#answercallbackquery
-type AnswerCallbackQueryP struct {
+type AnswerCallbackQuery struct {
 	CallbackQueryID string `json:"callback_query_id"`
 	Text            string `json:"text,omitempty"`
 	ShowAlert       bool   `json:"show_alert,omitempty"`
@@ -903,7 +911,7 @@ type AnswerCallbackQueryP struct {
 // AnswerCallbackQuery sends answers to callback queries sent from inline keyboards.
 // Returns True on success.
 // See https://core.telegram.org/bots/api#answercallbackquery
-func (api *API) AnswerCallbackQuery(params AnswerCallbackQueryP) (bool, error) {
+func (api *API) AnswerCallbackQuery(params AnswerCallbackQuery) (bool, error) {
 	req := NewRequest[bool]("answerCallbackQuery", params)
 	return req.Do(api)
 }
@@ -911,7 +919,7 @@ func (api *API) AnswerCallbackQuery(params AnswerCallbackQueryP) (bool, error) {
 // AnswerCallbackQueryWithContext is the context-aware variant of AnswerCallbackQuery.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#answercallbackquery
-func (api *API) AnswerCallbackQueryWithContext(ctx context.Context, params AnswerCallbackQueryP) (bool, error) {
+func (api *API) AnswerCallbackQueryWithContext(ctx context.Context, params AnswerCallbackQuery) (bool, error) {
 	req := NewRequest[bool]("answerCallbackQuery", params)
 	return req.DoWithContext(ctx, api)
 }

tgapi/messages_types.go

@@ -1,64 +1,222 @@
 package tgapi
 
-import "git.scuroneko.dev/scuroneko/extypes"
+import (
+	"encoding/json"
+
+	"git.scuroneko.dev/scuroneko/extypes"
+)
 
 // MessageID represents a message identifier wrapper returned by some API methods.
 type MessageID struct {
 	MessageID int `json:"message_id"`
 }
 
-// MessageReplyMarkup represents an inline keyboard markup for a message.
-// It is used in the Message type.
-type MessageReplyMarkup struct {
-	InlineKeyboard [][]InlineKeyboardButton `json:"inline_keyboard"`
-}
-
 // DirectMessageTopic represents a forum topic in a direct message.
 type DirectMessageTopic struct {
 	TopicID int64 `json:"topic_id"`
 	User    *User `json:"user,omitempty"`
 }
 
+type MessageOriginType string
+
+const (
+	MessageOriginUserType       = "user"
+	MessageOriginHiddenUserType = "hidden_user"
+	MessageOriginChatType       = "chat"
+	MessageOriginChannel        = "channel"
+)
+
+type MessageOrigin struct {
+	Type MessageOriginType `json:"type"`
+	Date int64             `json:"date"`
+
+	SenderUser *User `json:"sender_user,omitempty"`
+
+	SenderUserName string `json:"sender_user_name,omitempty"`
+
+	SenderChat *Chat `json:"sender_chat,omitempty"`
+
+	Chat      *Chat `json:"chat,omitempty"`
+	MessageID int   `json:"message_id"`
+
+	AuthorSignature string `json:"author_signature,omitempty"`
+}
+
+type ExternalReplyInfo struct {
+	Origin             MessageOrigin       `json:"origin"`
+	Chat               *Chat               `json:"chat,omitempty"`
+	MessageID          int                 `json:"message_id,omitempty"`
+	LinkPreviewOptions *LinkPreviewOptions `json:"link_preview_options,omitempty"`
+	Animation          *Animation          `json:"animation,omitempty"`
+	Audio              *Audio              `json:"audio,omitempty"`
+	Document           *Document           `json:"document,omitempty"`
+	PaidMedia          *PaidMediaInfo      `json:"paid_media,omitempty"`
+	Photo              []PhotoSize         `json:"photo,omitempty"`
+	Sticker            *Sticker            `json:"sticker,omitempty"`
+	Story              *Story              `json:"story,omitempty"`
+	Video              *Video              `json:"video,omitempty"`
+	VideoNote          *VideoNote          `json:"video_note,omitempty"`
+	Voice              *Voice              `json:"voice,omitempty"`
+	HasMediaSpoiler    bool                `json:"has_media_spoiler,omitempty"`
+	Checklist          *Checklist          `json:"checklist,omitempty"`
+	Contact            *Contact            `json:"contact,omitempty"`
+	Dice               *Dice               `json:"dice,omitempty"`
+	Game               *Game               `json:"game,omitempty"`
+	Giveaway           *Giveaway           `json:"giveaway,omitempty"`
+	GiveawayWinners    *GiveawayWinners    `json:"giveaway_winners,omitempty"`
+	Invoice            *Invoice            `json:"invoice,omitempty"`
+	Location           *Location           `json:"location,omitempty"`
+	Poll               *Poll               `json:"poll,omitempty"`
+	Venue              *Venue              `json:"venue,omitempty"`
+}
+
+type TextQuote struct {
+	Text     string          `json:"text"`
+	Entities []MessageEntity `json:"entities"`
+	Position int             `json:"position"`
+	IsManual bool            `json:"is_manual,omitempty"`
+}
+
+type MessageAutoDeleteTimerChanged struct {
+	MessageAutoDeleteTime int `json:"message_auto_delete_time"`
+}
+
+type DirectMessagePriceChanged struct {
+	AreDirectMessagesEnabled bool `json:"are_direct_messages_enabled"`
+	DirectMessageStarCount   int  `json:"direct_message_star_count,omitempty"`
+}
+
+type PaidMessagePriceChanged struct {
+	PaidMessageStarCount int `json:"paid_message_star_count"`
+}
+
 // Message represents a Telegram message.
 // See https://core.telegram.org/bots/api#message
 type Message struct {
-	MessageID            int                 `json:"message_id"`
-	MessageThreadID      int                 `json:"message_thread_id,omitempty"`
-	DirectMessageTopic   *DirectMessageTopic `json:"direct_message_topic,omitempty"`
-	BusinessConnectionId string              `json:"business_connection_id,omitempty"`
-	From                 *User               `json:"from,omitempty"`
+	MessageID          int                 `json:"message_id"`
+	MessageThreadID    int                 `json:"message_thread_id,omitempty"`
+	DirectMessageTopic *DirectMessageTopic `json:"direct_message_topic,omitempty"`
+	From               *User               `json:"from,omitempty"`
 
-	SenderChat        *Chat  `json:"sender_chat,omitempty"`
-	SenderBoostCount  int    `json:"sender_boost_count,omitempty"`
-	SenderBusinessBot *User  `json:"sender_business_bot,omitempty"`
-	SenderTag         string `json:"sender_tag,omitempty"`
-	Chat              *Chat  `json:"chat,omitempty"`
+	SenderChat           *Chat          `json:"sender_chat,omitempty"`
+	SenderBoostCount     int            `json:"sender_boost_count,omitempty"`
+	SenderBusinessBot    *User          `json:"sender_business_bot,omitempty"`
+	SenderTag            string         `json:"sender_tag,omitempty"`
+	Date                 int            `json:"date"`
+	BusinessConnectionId string         `json:"business_connection_id,omitempty"`
+	Chat                 *Chat          `json:"chat,omitempty"`
+	ForwardOrigin        *MessageOrigin `json:"forward_origin,omitempty"`
 
-	IsTopicMessage     bool     `json:"is_topic_message,omitempty"`
-	IsAutomaticForward bool     `json:"is_automatic_forward,omitempty"`
-	IsFromOffline      bool     `json:"is_from_offline,omitempty"`
-	IsPaidPost         bool     `json:"is_paid_post,omitempty"`
-	MediaGroupId       string   `json:"media_group_id,omitempty"`
-	AuthorSignature    string   `json:"author_signature,omitempty"`
-	PaidStarCount      int      `json:"paid_star_count,omitempty"`
-	ReplyToMessage     *Message `json:"reply_to_message,omitempty"`
+	IsTopicMessage     bool               `json:"is_topic_message,omitempty"`
+	IsAutomaticForward bool               `json:"is_automatic_forward,omitempty"`
+	ReplyToMessage     *Message           `json:"reply_to_message,omitempty"`
+	ExternalReply      *ExternalReplyInfo `json:"external_reply,omitempty"`
+	Quote              *TextQuote         `json:"quote,omitempty"`
 
-	Text string `json:"text"`
-
-	Photo           extypes.Slice[PhotoSize] `json:"photo,omitempty"`
-	Caption         string                   `json:"caption,omitempty"`
-	CaptionEntities []MessageEntity          `json:"caption_entities,omitempty"`
-
-	Date     int `json:"date"`
-	EditDate int `json:"edit_date"`
-
-	ReplyMarkup *MessageReplyMarkup `json:"reply_markup,omitempty"`
+	ReplyToStory           *Story `json:"reply_to_story,omitempty"`
+	ReplyToChecklistTaskID int    `json:"reply_to_checklist_task_id,omitempty"`
+	ReplyToPollOptionID    string `json:"reply_to_poll_option_id,omitempty"`
+	ViaBot                 *User  `json:"via_bot,omitempty"`
+	EditDate               int    `json:"edit_date,omitempty"`
+	HasProtectedContent    bool   `json:"has_protected_content,omitempty"`
+	IsFromOffline          bool   `json:"is_from_offline,omitempty"`
+	IsPaidPost             bool   `json:"is_paid_post,omitempty"`
+	MediaGroupId           string `json:"media_group_id,omitempty"`
+	AuthorSignature        string `json:"author_signature,omitempty"`
+	PaidStarCount          int    `json:"paid_star_count,omitempty"`
 
+	Text               string              `json:"text"`
 	Entities           []MessageEntity     `json:"entities,omitempty"`
 	LinkPreviewOptions *LinkPreviewOptions `json:"link_preview_options,omitempty"`
 	SuggestedPostInfo  *SuggestedPostInfo  `json:"suggested_post_info,omitempty"`
+	EffectID           string              `json:"effect_id,omitempty"`
 
-	EffectID string `json:"effect_id,omitempty"`
+	Animation             *Animation               `json:"animation,omitempty"`
+	Audio                 *Audio                   `json:"audio,omitempty"`
+	Document              *Document                `json:"document,omitempty"`
+	PaidMedia             *PaidMediaInfo           `json:"paid_media,omitempty"`
+	Photo                 extypes.Slice[PhotoSize] `json:"photo,omitempty"`
+	Sticker               *Sticker                 `json:"sticker,omitempty"`
+	Story                 *Story                   `json:"story,omitempty"`
+	Video                 *Video                   `json:"video,omitempty"`
+	VideoNote             *VideoNote               `json:"video_note,omitempty"`
+	Voice                 *Voice                   `json:"voice,omitempty"`
+	Caption               string                   `json:"caption,omitempty"`
+	CaptionEntities       []MessageEntity          `json:"caption_entities,omitempty"`
+	ShowCaptionAboveMedia bool                     `json:"show_caption_above_media,omitempty"`
+	HasMediaSpoiler       bool                     `json:"has_media_spoiler,omitempty"`
+	Checklist             *Checklist               `json:"checklist,omitempty"`
+	Contact               *Contact                 `json:"contact,omitempty"`
+	Dice                  *Dice                    `json:"dice,omitempty"`
+	Game                  *Game                    `json:"game,omitempty"`
+	Poll                  *Poll                    `json:"poll,omitempty"`
+	Venue                 *Venue                   `json:"venue,omitempty"`
+	Location              *Location                `json:"location,omitempty"`
+
+	NewChatMembers                []User                         `json:"new_chat_members,omitempty"`
+	LeftChatMember                *User                          `json:"left_chat_member,omitempty"`
+	ChatOwnerLeft                 *ChatOwnerLeft                 `json:"chat_owner_left,omitempty"`
+	ChatOwnerChanged              *ChatOwnerChanged              `json:"chat_owner_changed,omitempty"`
+	NewChatTitle                  string                         `json:"new_chat_title,omitempty"`
+	NewChatPhoto                  []PhotoSize                    `json:"new_chat_photo,omitempty"`
+	DeleteChatPhoto               bool                           `json:"delete_chat_photo,omitempty"`
+	GroupChatCreated              bool                           `json:"group_chat_created,omitempty"`
+	SupergroupChatCreated         bool                           `json:"supergroup_chat_created,omitempty"`
+	ChannelChatCreated            bool                           `json:"channel_chat_created,omitempty"`
+	MessageAutoDeleteTimerChanged *MessageAutoDeleteTimerChanged `json:"message_auto_delete_timer_changed,omitempty"`
+	MigrateToChatID               int64                          `json:"migrate_to_chat_id,omitempty"`
+	MigrateFromChatID             int64                          `json:"migrate_from_chat_id,omitempty"`
+	PinnedMessage                 *MaybeInaccessibleMessage      `json:"pinned_message,omitempty"`
+
+	Invoice           *Invoice           `json:"invoice,omitempty"`
+	SuccessfulPayment *SuccessfulPayment `json:"successful_payment,omitempty"`
+	RefundedPayment   *RefundedPayment   `json:"refunded_payment,omitempty"`
+	UsersShared       *UsersShared       `json:"users_shared,omitempty"`
+	ChatShared        *ChatShared        `json:"chat_shared,omitempty"`
+	Gift              *GiftInfo          `json:"gift,omitempty"`
+	UniqueGift        *UniqueGiftInfo    `json:"unique_gift,omitempty"`
+	GiftUpgradeSent   *GiftInfo          `json:"gift_upgrade_sent,omitempty"`
+
+	ConnectedWebsite        string                   `json:"connected_website,omitempty"`
+	WriteAccessAllowed      *WriteAccessAllowed      `json:"write_access_allowed,omitempty"`
+	PassportData            *PassportData            `json:"passport_data,omitempty"`
+	ProximityAlertTriggered *ProximityAlertTriggered `json:"proximity_alert_triggered,omitempty"`
+	BoostAdded              *ChatBoostAdded          `json:"boost_added,omitempty"`
+	ChatBackgroundSet       *ChatBackground          `json:"chat_background_set,omitempty"`
+
+	ChecklistTaskDone         *ChecklistTaskDone         `json:"checklist_task_done,omitempty"`
+	ChecklistTasksAdded       *ChecklistTasksAdded       `json:"checklist_tasks_added,omitempty"`
+	DirectMessagePriceChanged *DirectMessagePriceChanged `json:"direct_message_price_changed,omitempty"`
+	ForumTopicCreated         *ForumTopicCreated         `json:"forum_topic_created,omitempty"`
+	ForumTopicEdited          *ForumTopicEdited          `json:"forum_topic_edited,omitempty"`
+	ForumTopicClosed          *ForumTopicClosed          `json:"forum_topic_closed,omitempty"`
+	ForumTopicReopened        *ForumTopicReopened        `json:"forum_topic_reopened,omitempty"`
+	GeneralForumTopicHidden   *GeneralForumTopicHidden   `json:"general_forum_topic_hidden,omitempty"`
+	GeneralForumTopicUnhidden *GeneralForumTopicUnhidden `json:"general_forum_topic_unhidden,omitempty"`
+
+	GiveawayCreated   *GiveawayCreated   `json:"giveaway_created,omitempty"`
+	Giveaway          *Giveaway          `json:"giveaway,omitempty"`
+	GiveawayWinners   *GiveawayWinners   `json:"giveaway_winners,omitempty"`
+	GiveawayCompleted *GiveawayCompleted `json:"giveaway_completed,omitempty"`
+
+	ManagedBotCreated       *ManagedBotCreated       `json:"managed_bot_created,omitempty"`
+	PaidMessagePriceChanged *PaidMessagePriceChanged `json:"paid_message_price_changed,omitempty"`
+	PollOptionAdded         *PollOptionAdded         `json:"poll_option_added,omitempty"`
+	PollOptionDeleted       *PollOptionDeleted       `json:"poll_option_deleted,omitempty"`
+
+	SuggestedPostApproved       *SuggestedPostApproved       `json:"suggested_post_approved,omitempty"`
+	SuggestedPostApprovalFailed *SuggestedPostApprovalFailed `json:"suggested_post_approval_failed,omitempty"`
+	SuggestedPostDeclined       *SuggestedPostDeclined       `json:"suggested_post_declined,omitempty"`
+	SuggestedPostPaid           *SuggestedPostPaid           `json:"suggested_post_paid,omitempty"`
+	SuggestedPostRefunded       *SuggestedPostRefunded       `json:"suggested_post_refunded,omitempty"`
+
+	VideoChatScheduled           *VideoChatScheduled           `json:"video_chat_scheduled,omitempty"`
+	VideoChatStarted             *VideoChatStarted             `json:"video_chat_started,omitempty"`
+	VideoChatEnded               *VideoChatEnded               `json:"video_chat_ended,omitempty"`
+	VideoChatParticipantsInvited *VideoChatParticipantsInvited `json:"video_chat_participants_invited,omitempty"`
+
+	WebAppData  *WebAppData           `json:"web_app_data,omitempty"`
+	ReplyMarkup *InlineKeyboardMarkup `json:"reply_markup,omitempty"`
 }
 
 // InaccessibleMessage describes a message that was deleted or is otherwise inaccessible.
@@ -71,7 +229,80 @@ type InaccessibleMessage struct {
 
 // MaybeInaccessibleMessage is a union type that can be either Message or InaccessibleMessage.
 // See https://core.telegram.org/bots/api#maybeinaccessiblemessage
-type MaybeInaccessibleMessage interface{ Message | InaccessibleMessage }
+type MaybeInaccessibleMessage struct {
+	msg *Message
+	ina *InaccessibleMessage
+}
+
+// UnmarshalJSON decodes either an accessible Message or an InaccessibleMessage.
+func (m *MaybeInaccessibleMessage) UnmarshalJSON(data []byte) error {
+	tmp := struct {
+		Date int `json:"date"`
+	}{}
+	if err := json.Unmarshal(data, &tmp); err != nil {
+		return err
+	}
+	var err error
+	if tmp.Date > 0 {
+		err = json.Unmarshal(data, &m.msg)
+	} else {
+		err = json.Unmarshal(data, &m.ina)
+	}
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// MarshalJSON encodes the populated accessible or inaccessible message payload.
+func (m *MaybeInaccessibleMessage) MarshalJSON() ([]byte, error) {
+	if m.msg != nil {
+		return json.Marshal(m.msg)
+	} else if m.ina != nil {
+		return json.Marshal(m.ina)
+	}
+	return json.Marshal(nil)
+}
+
+// Message returns the accessible message payload when present.
+func (m *MaybeInaccessibleMessage) Message() *Message {
+	return m.msg
+}
+
+// InaccessibleMessage returns the inaccessible message payload when present.
+func (m *MaybeInaccessibleMessage) InaccessibleMessage() *InaccessibleMessage {
+	return m.ina
+}
+
+// IsAccessible reports whether the payload is an accessible message.
+func (m *MaybeInaccessibleMessage) IsAccessible() bool {
+	return m.msg != nil
+}
+
+// IsInaccessible reports whether the payload is an inaccessible message.
+func (m *MaybeInaccessibleMessage) IsInaccessible() bool {
+	return m.ina != nil
+}
+
+// MessageID returns the message identifier from either payload form.
+func (m *MaybeInaccessibleMessage) MessageID() int {
+	if m.IsAccessible() {
+		return m.msg.MessageID
+	} else if m.IsInaccessible() {
+		return m.ina.MessageID
+	}
+	return 0
+}
+
+// Chat returns the chat from either payload form.
+func (m *MaybeInaccessibleMessage) Chat() *Chat {
+	if m.IsAccessible() {
+		return m.msg.Chat
+	} else if m.IsInaccessible() {
+		return &m.ina.Chat
+	}
+	return nil
+}
 
 // MessageEntityType represents the type of a message entity.
 type MessageEntityType string
@@ -147,6 +378,7 @@ type ReplyParameters struct {
 	QuoteEntities            []MessageEntity `json:"quote_entities,omitempty"`
 	QuotePosition            int             `json:"quote_position,omitempty"`
 	ChecklistTaskID          int             `json:"checklist_task_id,omitempty"`
+	PollOptionID             string          `json:"poll_option_id,omitempty"`
 }
 
 // LinkPreviewOptions describes the options used for link preview generation.
@@ -197,15 +429,16 @@ const (
 // KeyboardButton represents one button of the reply keyboard.
 // See https://core.telegram.org/bots/api#keyboardbutton
 type KeyboardButton struct {
-	Text              string                      `json:"text"`
-	IconCustomEmojiID string                      `json:"icon_custom_emoji_id,omitempty"`
-	Style             KeyboardButtonStyle         `json:"style,omitempty"`
-	RequestUsers      *KeyboardButtonRequestUsers `json:"request_users,omitempty"`
-	RequestChat       *KeyboardButtonRequestChat  `json:"request_chat,omitempty"`
-	RequestContact    bool                        `json:"request_contact,omitempty"`
-	RequestLocation   bool                        `json:"request_location,omitempty"`
-	RequestPoll       *KeyboardButtonPollType     `json:"request_poll,omitempty"`
-	WebApp            *WebAppInfo                 `json:"web_app,omitempty"`
+	Text              string                           `json:"text"`
+	IconCustomEmojiID string                           `json:"icon_custom_emoji_id,omitempty"`
+	Style             KeyboardButtonStyle              `json:"style,omitempty"`
+	RequestUsers      *KeyboardButtonRequestUsers      `json:"request_users,omitempty"`
+	RequestChat       *KeyboardButtonRequestChat       `json:"request_chat,omitempty"`
+	RequestManagedBot *KeyboardButtonRequestManagedBot `json:"request_managed_bot,omitempty"`
+	RequestContact    bool                             `json:"request_contact,omitempty"`
+	RequestLocation   bool                             `json:"request_location,omitempty"`
+	RequestPoll       *KeyboardButtonPollType          `json:"request_poll,omitempty"`
+	WebApp            *WebAppInfo                      `json:"web_app,omitempty"`
 }
 
 // KeyboardButtonRequestUsers defines criteria used to request suitable users.
@@ -236,6 +469,14 @@ type KeyboardButtonRequestChat struct {
 	RequestPhoto            bool                     `json:"request_photo,omitempty"`
 }
 
+// KeyboardButtonRequestManagedBot defines criteria used to request a managed bot.
+// See https://core.telegram.org/bots/api#keyboardbuttonrequestmanagedbot
+type KeyboardButtonRequestManagedBot struct {
+	RequestID         int32  `json:"request_id"`
+	SuggestedName     string `json:"suggested_name,omitempty"`
+	SuggestedUsername string `json:"suggested_username,omitempty"`
+}
+
 // KeyboardButtonPollType represents the type of a poll that may be created from a keyboard button.
 // See https://core.telegram.org/bots/api#keyboardbuttonpolltype
 type KeyboardButtonPollType struct {
@@ -275,42 +516,6 @@ type CallbackQuery struct {
 	GameShortName   string   `json:"game_short_name,omitempty"`
 }
 
-// InputPollOption contains information about one answer option in a poll to be sent.
-// See https://core.telegram.org/bots/api#inputpolloption
-type InputPollOption struct {
-	Text          string          `json:"text"`
-	TextParseMode ParseMode       `json:"text_parse_mode,omitempty"`
-	TextEntities  []MessageEntity `json:"text_entities,omitempty"`
-}
-
-// PollType represents the type of a poll.
-type PollType string
-
-const (
-	// PollTypeRegular identifies a regular poll.
-	PollTypeRegular PollType = "regular"
-	// PollTypeQuiz identifies a quiz poll.
-	PollTypeQuiz PollType = "quiz"
-)
-
-// InputChecklistTask describes a task in a checklist.
-type InputChecklistTask struct {
-	ID           int             `json:"id"`
-	Text         string          `json:"text"`
-	ParseMode    ParseMode       `json:"parse_mode,omitempty"`
-	TextEntities []MessageEntity `json:"text_entities,omitempty"`
-}
-
-// InputChecklist represents a checklist to be sent.
-type InputChecklist struct {
-	Title                   string               `json:"title"`
-	ParseMode               ParseMode            `json:"parse_mode,omitempty"`
-	TitleEntities           []MessageEntity      `json:"title_entities,omitempty"`
-	Tasks                   []InputChecklistTask `json:"tasks"`
-	OtherCanAddTasks        bool                 `json:"other_can_add_tasks,omitempty"`
-	OtherCanMarkTasksAsDone bool                 `json:"other_can_mark_tasks_as_done,omitempty"`
-}
-
 // ChatActionType represents the type of chat action.
 type ChatActionType string
 
@@ -392,3 +597,70 @@ type SuggestedPostParameters struct {
 	Price    SuggestedPostPrice `json:"price"`
 	SendDate int                `json:"send_date"`
 }
+
+// ManagedBotCreated describes a service message about a newly created managed bot.
+// See https://core.telegram.org/bots/api#managedbotcreated
+type ManagedBotCreated struct {
+	Bot User `json:"bot"`
+}
+
+// ManagedBotUpdated describes an update about a managed bot and its manager.
+// See https://core.telegram.org/bots/api#managedbotupdated
+type ManagedBotUpdated struct {
+	User User `json:"user"`
+	Bot  User `json:"bot"`
+}
+
+type SharedUser struct {
+	UserID    int64       `json:"user_id"`
+	FirstName string      `json:"first_name,omitempty"`
+	LastName  string      `json:"last_name,omitempty"`
+	Username  string      `json:"username,omitempty"`
+	Photo     []PhotoSize `json:"photo,omitempty"`
+}
+type UsersShared struct {
+	RequestID int          `json:"request_id"`
+	Users     []SharedUser `json:"users"`
+}
+type ChatShared struct {
+	RequestID int         `json:"request_id"`
+	ChatID    int64       `json:"chat_id"`
+	Title     string      `json:"title,omitempty"`
+	Username  string      `json:"username,omitempty"`
+	Photo     []PhotoSize `json:"photo,omitempty"`
+}
+
+type SuggestedPostApproved struct {
+	SuggestedPostMessage *Message           `json:"suggested_post_message,omitempty"`
+	Price                SuggestedPostPrice `json:"price"`
+	SendDate             int                `json:"send_date"`
+}
+type SuggestedPostApprovalFailed struct {
+	SuggestedPostMessage *Message           `json:"suggested_post_message,omitempty"`
+	Price                SuggestedPostPrice `json:"price"`
+}
+type SuggestedPostDeclined struct {
+	SuggestedPostMessage *Message `json:"suggested_post_message,omitempty"`
+	Comment              string   `json:"comment,omitempty"`
+}
+type SuggestedPostPaid struct {
+	SuggestedPostMessage *Message    `json:"suggested_post_message,omitempty"`
+	Currency             string      `json:"currency"`
+	Amount               int         `json:"amount"`
+	StarAmount           *StarAmount `json:"star_amount,omitempty"`
+}
+type SuggestedPostRefunded struct {
+	SuggestedPostMessage *Message `json:"suggested_post_message,omitempty"`
+	Reason               string   `json:"reason,omitempty"`
+}
+
+type VideoChatScheduled struct {
+	StartDate int64 `json:"start_date"`
+}
+type VideoChatStarted struct{}
+type VideoChatEnded struct {
+	Duration int64 `json:"duration"`
+}
+type VideoChatParticipantsInvited struct {
+	Users []User `json:"users"`
+}

tgapi/methods.go

@@ -33,6 +33,48 @@ func (api *API) GetMeWithContext(ctx context.Context) (User, error) {
 	return req.DoWithContext(ctx, api)
 }
 
+// GetManagedBotToken holds parameters for the getManagedBotToken method.
+// See https://core.telegram.org/bots/api#getmanagedbottoken
+type GetManagedBotToken struct {
+	UserID int64 `json:"user_id"`
+}
+
+// GetManagedBotToken returns the current token of a managed bot.
+// See https://core.telegram.org/bots/api#getmanagedbottoken
+func (api *API) GetManagedBotToken(params GetManagedBotToken) (string, error) {
+	req := NewRequest[string]("getManagedBotToken", params)
+	return req.Do(api)
+}
+
+// GetManagedBotTokenWithContext is the context-aware variant of GetManagedBotToken.
+// It executes the same request but uses ctx for cancellation and deadlines.
+// See https://core.telegram.org/bots/api#getmanagedbottoken
+func (api *API) GetManagedBotTokenWithContext(ctx context.Context, params GetManagedBotToken) (string, error) {
+	req := NewRequest[string]("getManagedBotToken", params)
+	return req.DoWithContext(ctx, api)
+}
+
+// ReplaceManagedBotToken holds parameters for the replaceManagedBotToken method.
+// See https://core.telegram.org/bots/api#replacemanagedbottoken
+type ReplaceManagedBotToken struct {
+	UserID int64 `json:"user_id"`
+}
+
+// ReplaceManagedBotToken replaces and returns the token of a managed bot.
+// See https://core.telegram.org/bots/api#replacemanagedbottoken
+func (api *API) ReplaceManagedBotToken(params ReplaceManagedBotToken) (string, error) {
+	req := NewRequest[string]("replaceManagedBotToken", params)
+	return req.Do(api)
+}
+
+// ReplaceManagedBotTokenWithContext is the context-aware variant of ReplaceManagedBotToken.
+// It executes the same request but uses ctx for cancellation and deadlines.
+// See https://core.telegram.org/bots/api#replacemanagedbottoken
+func (api *API) ReplaceManagedBotTokenWithContext(ctx context.Context, params ReplaceManagedBotToken) (string, error) {
+	req := NewRequest[string]("replaceManagedBotToken", params)
+	return req.DoWithContext(ctx, api)
+}
+
 // LogOut logs the bot out from the cloud Bot API server.
 // Returns true on success.
 // See https://core.telegram.org/bots/api#logout
@@ -80,13 +122,13 @@ func (api *API) GetUpdatesWithContext(ctx context.Context, params UpdateParams)
 	return req.DoWithContext(ctx, api)
 }
 
-// SetWebhookP holds parameters for the setWebhook method.
+// SetWebhook holds parameters for the setWebhook method.
 // To upload a self-signed certificate, use Uploader.SetWebhook.
 // See https://core.telegram.org/bots/api#setwebhook
-type SetWebhookP struct {
+type SetWebhook struct {
 	URL                string       `json:"url"`
 	IPAddress          string       `json:"ip_address,omitempty"`
-	MaxConnections     int          `json:"max_connections,omitempty"`
+	MaxConnections     int8         `json:"max_connections,omitempty"`
 	AllowedUpdates     []UpdateType `json:"allowed_updates,omitempty"`
 	DropPendingUpdates bool         `json:"drop_pending_updates,omitempty"`
 	SecretToken        string       `json:"secret_token,omitempty"`
@@ -96,7 +138,7 @@ type SetWebhookP struct {
 // For certificate upload, use Uploader.SetWebhook.
 // Returns true on success.
 // See https://core.telegram.org/bots/api#setwebhook
-func (api *API) SetWebhook(params SetWebhookP) (bool, error) {
+func (api *API) SetWebhook(params SetWebhook) (bool, error) {
 	req := NewRequest[bool]("setWebhook", params)
 	return req.Do(api)
 }
@@ -105,21 +147,21 @@ func (api *API) SetWebhook(params SetWebhookP) (bool, error) {
 // It executes the same request but uses ctx for cancellation and deadlines.
 // For certificate upload, use Uploader.SetWebhook.
 // See https://core.telegram.org/bots/api#setwebhook
-func (api *API) SetWebhookWithContext(ctx context.Context, params SetWebhookP) (bool, error) {
+func (api *API) SetWebhookWithContext(ctx context.Context, params SetWebhook) (bool, error) {
 	req := NewRequest[bool]("setWebhook", params)
 	return req.DoWithContext(ctx, api)
 }
 
-// DeleteWebhookP holds parameters for the deleteWebhook method.
+// DeleteWebhook holds parameters for the deleteWebhook method.
 // See https://core.telegram.org/bots/api#deletewebhook
-type DeleteWebhookP struct {
+type DeleteWebhook struct {
 	DropPendingUpdates bool `json:"drop_pending_updates,omitempty"`
 }
 
 // DeleteWebhook removes the current webhook integration.
 // Returns true on success.
 // See https://core.telegram.org/bots/api#deletewebhook
-func (api *API) DeleteWebhook(params DeleteWebhookP) (bool, error) {
+func (api *API) DeleteWebhook(params DeleteWebhook) (bool, error) {
 	req := NewRequest[bool]("deleteWebhook", params)
 	return req.Do(api)
 }
@@ -127,7 +169,7 @@ func (api *API) DeleteWebhook(params DeleteWebhookP) (bool, error) {
 // DeleteWebhookWithContext is the context-aware variant of DeleteWebhook.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#deletewebhook
-func (api *API) DeleteWebhookWithContext(ctx context.Context, params DeleteWebhookP) (bool, error) {
+func (api *API) DeleteWebhookWithContext(ctx context.Context, params DeleteWebhook) (bool, error) {
 	req := NewRequest[bool]("deleteWebhook", params)
 	return req.DoWithContext(ctx, api)
 }
@@ -147,15 +189,15 @@ func (api *API) GetWebhookInfoWithContext(ctx context.Context) (WebhookInfo, err
 	return req.DoWithContext(ctx, api)
 }
 
-// GetFileP holds parameters for the getFile method.
+// GetFile holds parameters for the getFile method.
 // See https://core.telegram.org/bots/api#getfile
-type GetFileP struct {
-	FileId string `json:"file_id"`
+type GetFile struct {
+	FileID string `json:"file_id"`
 }
 
 // GetFile returns basic information about a file and prepares it for downloading.
 // See https://core.telegram.org/bots/api#getfile
-func (api *API) GetFile(params GetFileP) (File, error) {
+func (api *API) GetFile(params GetFile) (File, error) {
 	req := NewRequest[File]("getFile", params)
 	return req.Do(api)
 }
@@ -163,7 +205,7 @@ func (api *API) GetFile(params GetFileP) (File, error) {
 // GetFileWithContext is the context-aware variant of GetFile.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#getfile
-func (api *API) GetFileWithContext(ctx context.Context, params GetFileP) (File, error) {
+func (api *API) GetFileWithContext(ctx context.Context, params GetFile) (File, error) {
 	req := NewRequest[File]("getFile", params)
 	return req.DoWithContext(ctx, api)
 }

tgapi/methods_test.go

@@ -151,3 +151,60 @@ func TestGetUpdatesOmitsAllowedUpdatesWhenEmpty(t *testing.T) {
 		t.Fatalf("expected allowed_updates to be omitted, got %v", gotBody["allowed_updates"])
 	}
 }
+
+func TestSetChatMenuButtonSendsStructuredMenuButton(t *testing.T) {
+	var gotBody map[string]any
+
+	client := &http.Client{
+		Transport: roundTripFunc(func(req *http.Request) (*http.Response, error) {
+			body, err := io.ReadAll(req.Body)
+			if err != nil {
+				t.Fatalf("failed to read request body: %v", err)
+			}
+			if err := json.Unmarshal(body, &gotBody); err != nil {
+				t.Fatalf("failed to decode request body: %v", err)
+			}
+			return &http.Response{
+				StatusCode: http.StatusOK,
+				Header:     http.Header{"Content-Type": []string{"application/json"}},
+				Body:       io.NopCloser(strings.NewReader(`{"ok":true,"result":true}`)),
+			}, nil
+		}),
+	}
+
+	api := NewAPI(
+		NewAPIOpts("token").
+			SetAPIUrl("https://example.test").
+			SetHTTPClient(client),
+	)
+	defer func() {
+		if err := api.Close(); err != nil {
+			t.Fatalf("Close returned error: %v", err)
+		}
+	}()
+
+	text := "Open"
+	if _, err := api.SetChatMenuButton(SetChatMenuButton{
+		ChatID: 42,
+		MenuButton: &MenuButton{
+			Type: MenuButtonWebAppType,
+			Text: &text,
+			WebApp: &WebAppInfo{
+				URL: "https://example.test/app",
+			},
+		},
+	}); err != nil {
+		t.Fatalf("SetChatMenuButton returned error: %v", err)
+	}
+
+	menuButton, ok := gotBody["menu_button"].(map[string]any)
+	if !ok {
+		t.Fatalf("expected structured menu_button, got %#v", gotBody["menu_button"])
+	}
+	if menuButton["type"] != string(MenuButtonWebAppType) {
+		t.Fatalf("unexpected menu button type: %#v", menuButton["type"])
+	}
+	if menuButton["text"] != text {
+		t.Fatalf("unexpected menu button text: %#v", menuButton["text"])
+	}
+}

tgapi/methods_types.go

@@ -19,17 +19,3 @@ type EmptyParams struct{}
 
 // NoParams is a convenient instance of EmptyParams.
 var NoParams = EmptyParams{}
-
-// WebhookInfo describes the current webhook status.
-// See https://core.telegram.org/bots/api#webhookinfo
-type WebhookInfo struct {
-	URL                          string   `json:"url"`
-	HasCustomCertificate         bool     `json:"has_custom_certificate"`
-	PendingUpdateCount           int      `json:"pending_update_count"`
-	IPAddress                    string   `json:"ip_address,omitempty"`
-	LastErrorDate                int      `json:"last_error_date,omitempty"`
-	LastErrorMessage             string   `json:"last_error_message,omitempty"`
-	LastSynchronizationErrorDate int      `json:"last_synchronization_error_date,omitempty"`
-	MaxConnections               int      `json:"max_connections,omitempty"`
-	AllowedUpdates               []string `json:"allowed_updates,omitempty"`
-}

tgapi/parse_mode_test.go

@@ -7,7 +7,7 @@ import (
 )
 
 func TestParseNoneOmitsParseModeInJSON(t *testing.T) {
-	data, err := json.Marshal(SendMessageP{
+	data, err := json.Marshal(SendMessage{
 		ChatID:    42,
 		Text:      "hello",
 		ParseMode: ParseNone,
@@ -22,7 +22,7 @@ func TestParseNoneOmitsParseModeInJSON(t *testing.T) {
 }
 
 func TestParseModeStillSerializesExplicitModes(t *testing.T) {
-	data, err := json.Marshal(SendMessageP{
+	data, err := json.Marshal(SendMessage{
 		ChatID:    42,
 		Text:      "hello",
 		ParseMode: ParseMDV2,

tgapi/passport_methods.go

@@ -2,9 +2,9 @@ package tgapi
 
 import "context"
 
-// SetPassportDataErrorsP holds parameters for the setPassportDataErrors method.
+// SetPassportDataErrors holds parameters for the setPassportDataErrors method.
 // See https://core.telegram.org/bots/api#setpassportdataerrors
-type SetPassportDataErrorsP struct {
+type SetPassportDataErrors struct {
 	UserID int64                  `json:"user_id"`
 	Errors []PassportElementError `json:"errors"`
 }
@@ -12,7 +12,7 @@ type SetPassportDataErrorsP struct {
 // SetPassportDataErrors informs a user about Telegram Passport data errors.
 // Returns true on success.
 // See https://core.telegram.org/bots/api#setpassportdataerrors
-func (api *API) SetPassportDataErrors(params SetPassportDataErrorsP) (bool, error) {
+func (api *API) SetPassportDataErrors(params SetPassportDataErrors) (bool, error) {
 	req := NewRequest[bool]("setPassportDataErrors", params)
 	return req.Do(api)
 }
@@ -20,7 +20,7 @@ func (api *API) SetPassportDataErrors(params SetPassportDataErrorsP) (bool, erro
 // SetPassportDataErrorsWithContext is the context-aware variant of SetPassportDataErrors.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#setpassportdataerrors
-func (api *API) SetPassportDataErrorsWithContext(ctx context.Context, params SetPassportDataErrorsP) (bool, error) {
+func (api *API) SetPassportDataErrorsWithContext(ctx context.Context, params SetPassportDataErrors) (bool, error) {
 	req := NewRequest[bool]("setPassportDataErrors", params)
 	return req.DoWithContext(ctx, api)
 }

tgapi/passport_types.go

@@ -1,5 +1,64 @@
 package tgapi
 
+type PassportData struct {
+	Data        []EncryptedPassportElement `json:"data"`
+	Credentials EncryptedCredentials       `json:"credentials"`
+}
+type PassportFile struct {
+	FileID       string `json:"file_id"`
+	FileUniqueID string `json:"file_unique_id"`
+	FileSize     int64  `json:"file_size"`
+	FileDate     int64  `json:"file_date"`
+}
+type PassportElementType string
+
+const (
+	PassportPersonalDetailsType       PassportElementType = "personal_details"
+	PassportPassportType              PassportElementType = "passport"
+	PassportDriverLicenseType         PassportElementType = "driver_license"
+	PassportIdentityCardType          PassportElementType = "identity_card"
+	PassportInternalPassportType      PassportElementType = "internal_passport"
+	PassportAddressType               PassportElementType = "address"
+	PassportUtilityBillType           PassportElementType = "utility_bill"
+	PassportBankStatementType         PassportElementType = "bank_statement"
+	PassportRentalAgreementType       PassportElementType = "rental_agreement"
+	PassportPassportRegistrationType  PassportElementType = "passport_registration"
+	PassportTemporaryRegistrationType PassportElementType = "temporary_registration"
+	PassportPhoneNumberType           PassportElementType = "phone_number"
+	PassportEmailType                 PassportElementType = "email"
+)
+
+type EncryptedPassportElement struct {
+	Type        PassportElementType `json:"type"`
+	Data        string              `json:"data,omitempty"`
+	PhoneNumber string              `json:"phone_number,omitempty"`
+	Email       string              `json:"email,omitempty"`
+	Files       []PassportFile      `json:"files,omitempty"`
+	FrontSide   *PassportFile       `json:"front_side,omitempty"`
+	ReverseSide *PassportFile       `json:"reverse_side,omitempty"`
+	Selfie      *PassportFile       `json:"selfie,omitempty"`
+	Translation *PassportFile       `json:"translation,omitempty"`
+	Hash        string              `json:"hash,omitempty"`
+}
+type EncryptedCredentials struct {
+	Data   string `json:"data"`
+	Hash   string `json:"hash"`
+	Secret string `json:"secret"`
+}
+
 // PassportElementError is a JSON-serializable passport element error object.
 // See https://core.telegram.org/bots/api#passportelementerror
-type PassportElementError map[string]any
+type PassportElementError struct {
+	Source string              `json:"source"`
+	Type   PassportElementType `json:"type"`
+
+	FieldName string `json:"field_name,omitempty"`
+	DataHash  string `json:"data_hash,omitempty"`
+
+	FileHash   string   `json:"file_hash,omitempty"`
+	FileHashes []string `json:"file_hashes,omitempty"`
+
+	ElementHash string `json:"element_hash,omitempty"`
+
+	Message string `json:"message"`
+}

tgapi/payments_methods.go

@@ -2,9 +2,9 @@ package tgapi
 
 import "context"
 
-// SendInvoiceP holds parameters for the sendInvoice method.
+// SendInvoice holds parameters for the sendInvoice method.
 // See https://core.telegram.org/bots/api#sendinvoice
-type SendInvoiceP struct {
+type SendInvoice struct {
 	ChatID                int64 `json:"chat_id"`
 	MessageThreadID       int   `json:"message_thread_id,omitempty"`
 	DirectMessagesTopicID int   `json:"direct_messages_topic_id,omitempty"`
@@ -43,7 +43,7 @@ type SendInvoiceP struct {
 
 // SendInvoice sends an invoice.
 // See https://core.telegram.org/bots/api#sendinvoice
-func (api *API) SendInvoice(params SendInvoiceP) (Message, error) {
+func (api *API) SendInvoice(params SendInvoice) (Message, error) {
 	req := NewRequestWithChatID[Message]("sendInvoice", params, params.ChatID)
 	return req.Do(api)
 }
@@ -51,14 +51,14 @@ func (api *API) SendInvoice(params SendInvoiceP) (Message, error) {
 // SendInvoiceWithContext is the context-aware variant of SendInvoice.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#sendinvoice
-func (api *API) SendInvoiceWithContext(ctx context.Context, params SendInvoiceP) (Message, error) {
+func (api *API) SendInvoiceWithContext(ctx context.Context, params SendInvoice) (Message, error) {
 	req := NewRequestWithChatID[Message]("sendInvoice", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
 
-// CreateInvoiceLinkP holds parameters for the createInvoiceLink method.
+// CreateInvoiceLink holds parameters for the createInvoiceLink method.
 // See https://core.telegram.org/bots/api#createinvoicelink
-type CreateInvoiceLinkP struct {
+type CreateInvoiceLink struct {
 	BusinessConnectionID string `json:"business_connection_id,omitempty"`
 
 	Title         string         `json:"title"`
@@ -87,7 +87,7 @@ type CreateInvoiceLinkP struct {
 
 // CreateInvoiceLink creates an invoice link.
 // See https://core.telegram.org/bots/api#createinvoicelink
-func (api *API) CreateInvoiceLink(params CreateInvoiceLinkP) (string, error) {
+func (api *API) CreateInvoiceLink(params CreateInvoiceLink) (string, error) {
 	req := NewRequest[string]("createInvoiceLink", params)
 	return req.Do(api)
 }
@@ -95,14 +95,14 @@ func (api *API) CreateInvoiceLink(params CreateInvoiceLinkP) (string, error) {
 // CreateInvoiceLinkWithContext is the context-aware variant of CreateInvoiceLink.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#createinvoicelink
-func (api *API) CreateInvoiceLinkWithContext(ctx context.Context, params CreateInvoiceLinkP) (string, error) {
+func (api *API) CreateInvoiceLinkWithContext(ctx context.Context, params CreateInvoiceLink) (string, error) {
 	req := NewRequest[string]("createInvoiceLink", params)
 	return req.DoWithContext(ctx, api)
 }
 
-// AnswerShippingQueryP holds parameters for the answerShippingQuery method.
+// AnswerShippingQuery holds parameters for the answerShippingQuery method.
 // See https://core.telegram.org/bots/api#answershippingquery
-type AnswerShippingQueryP struct {
+type AnswerShippingQuery struct {
 	ShippingQueryID string           `json:"shipping_query_id"`
 	OK              bool             `json:"ok"`
 	ShippingOptions []ShippingOption `json:"shipping_options,omitempty"`
@@ -112,7 +112,7 @@ type AnswerShippingQueryP struct {
 // AnswerShippingQuery answers a shipping query.
 // Returns true on success.
 // See https://core.telegram.org/bots/api#answershippingquery
-func (api *API) AnswerShippingQuery(params AnswerShippingQueryP) (bool, error) {
+func (api *API) AnswerShippingQuery(params AnswerShippingQuery) (bool, error) {
 	req := NewRequest[bool]("answerShippingQuery", params)
 	return req.Do(api)
 }
@@ -120,14 +120,14 @@ func (api *API) AnswerShippingQuery(params AnswerShippingQueryP) (bool, error) {
 // AnswerShippingQueryWithContext is the context-aware variant of AnswerShippingQuery.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#answershippingquery
-func (api *API) AnswerShippingQueryWithContext(ctx context.Context, params AnswerShippingQueryP) (bool, error) {
+func (api *API) AnswerShippingQueryWithContext(ctx context.Context, params AnswerShippingQuery) (bool, error) {
 	req := NewRequest[bool]("answerShippingQuery", params)
 	return req.DoWithContext(ctx, api)
 }
 
-// AnswerPreCheckoutQueryP holds parameters for the answerPreCheckoutQuery method.
+// AnswerPreCheckoutQuery holds parameters for the answerPreCheckoutQuery method.
 // See https://core.telegram.org/bots/api#answerprecheckoutquery
-type AnswerPreCheckoutQueryP struct {
+type AnswerPreCheckoutQuery struct {
 	PreCheckoutQueryID string `json:"pre_checkout_query_id"`
 	OK                 bool   `json:"ok"`
 	ErrorMessage       string `json:"error_message,omitempty"`
@@ -136,7 +136,7 @@ type AnswerPreCheckoutQueryP struct {
 // AnswerPreCheckoutQuery answers a pre-checkout query.
 // Returns true on success.
 // See https://core.telegram.org/bots/api#answerprecheckoutquery
-func (api *API) AnswerPreCheckoutQuery(params AnswerPreCheckoutQueryP) (bool, error) {
+func (api *API) AnswerPreCheckoutQuery(params AnswerPreCheckoutQuery) (bool, error) {
 	req := NewRequest[bool]("answerPreCheckoutQuery", params)
 	return req.Do(api)
 }
@@ -144,7 +144,7 @@ func (api *API) AnswerPreCheckoutQuery(params AnswerPreCheckoutQueryP) (bool, er
 // AnswerPreCheckoutQueryWithContext is the context-aware variant of AnswerPreCheckoutQuery.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#answerprecheckoutquery
-func (api *API) AnswerPreCheckoutQueryWithContext(ctx context.Context, params AnswerPreCheckoutQueryP) (bool, error) {
+func (api *API) AnswerPreCheckoutQueryWithContext(ctx context.Context, params AnswerPreCheckoutQuery) (bool, error) {
 	req := NewRequest[bool]("answerPreCheckoutQuery", params)
 	return req.DoWithContext(ctx, api)
 }

tgapi/payments_types.go

@@ -7,6 +7,62 @@ type LabeledPrice struct {
 	Amount int    `json:"amount"`
 }
 
+type Invoice struct {
+	Title          string `json:"title"`
+	Description    string `json:"description"`
+	StartParameter string `json:"start_parameter"`
+	Currency       string `json:"currency"`
+	TotalAmount    int    `json:"total_amount"`
+}
+
+// ShippingQuery represents an incoming shipping query.
+// See https://core.telegram.org/bots/api#shippingquery
+type ShippingQuery struct {
+	ID              string          `json:"id"`
+	From            User            `json:"from"`
+	InvoicePayload  string          `json:"invoice_payload"`
+	ShippingAddress ShippingAddress `json:"shipping_address"`
+}
+
+// ShippingAddress represents a shipping address.
+// See https://core.telegram.org/bots/api#shippingaddress
+type ShippingAddress struct {
+	CountryCode string `json:"country_code"`
+	State       string `json:"state"`
+	City        string `json:"city"`
+	StreetLine1 string `json:"street_line1"`
+	StreetLine2 string `json:"street_line2"`
+	PostCode    string `json:"post_code"`
+}
+
+// OrderInfo represents information about an order.
+// See https://core.telegram.org/bots/api#orderinfo
+type OrderInfo struct {
+	Name            string          `json:"name"`
+	PhoneNumber     string          `json:"phone_number"`
+	Email           string          `json:"email"`
+	ShippingAddress ShippingAddress `json:"shipping_address"`
+}
+
+// PreCheckoutQuery represents an incoming pre-checkout query.
+// See https://core.telegram.org/bots/api#precheckoutquery
+type PreCheckoutQuery struct {
+	ID               string     `json:"id"`
+	From             User       `json:"from"`
+	Currency         string     `json:"currency"`
+	TotalAmount      int        `json:"total_amount"`
+	InvoicePayload   string     `json:"invoice_payload"`
+	ShippingOptionID string     `json:"shipping_option_id"`
+	OrderInfo        *OrderInfo `json:"order_info,omitempty"`
+}
+
+// PaidMediaPurchased represents a purchased paid media.
+// See https://core.telegram.org/bots/api#paidmediapurchased
+type PaidMediaPurchased struct {
+	From             User   `json:"from"`
+	PaidMediaPayload string `json:"paid_media_payload"`
+}
+
 // ShippingOption represents one shipping option.
 // See https://core.telegram.org/bots/api#shippingoption
 type ShippingOption struct {
@@ -14,3 +70,27 @@ type ShippingOption struct {
 	Title  string         `json:"title"`
 	Prices []LabeledPrice `json:"prices"`
 }
+
+type SuccessfulPayment struct {
+	Currency       string `json:"currency"`
+	TotalAmount    int    `json:"total_amount"`
+	InvoicePayload string `json:"invoice_payload"`
+
+	SubscriptionExpirationDate int        `json:"subscription_expiration_date,omitempty"`
+	IsRecurring                bool       `json:"is_recurring,omitempty"`
+	IsFirstRecurring           bool       `json:"is_first_recurring,omitempty"`
+	ShippingOptionID           string     `json:"shipping_option_id,omitempty"`
+	OrderInfo                  *OrderInfo `json:"order_info,omitempty"`
+
+	TelegramPaymentChargeID string `json:"telegram_payment_charge_id"`
+	ProviderPaymentChargeID string `json:"proviced_payment_charge_id"`
+}
+
+type RefundedPayment struct {
+	Currency       string `json:"currency"`
+	TotalAmount    int    `json:"total_amount"`
+	InvoicePayload string `json:"invoice_payload"`
+
+	TelegramPaymentChargeID string `json:"telegram_payment_charge_id"`
+	ProviderPaymentChargeID string `json:"proviced_payment_charge_id,omitempty"`
+}

tgapi/stars_methods.go

@@ -2,9 +2,9 @@ package tgapi
 
 import "context"
 
-// GetStarTransactionsP holds parameters for the getStarTransactions method.
+// GetStarTransactions holds parameters for the getStarTransactions method.
 // See https://core.telegram.org/bots/api#getstartransactions
-type GetStarTransactionsP struct {
+type GetStarTransactions struct {
 	Offset int `json:"offset,omitempty"`
 	Limit  int `json:"limit,omitempty"`
 }
@@ -26,7 +26,7 @@ func (api *API) GetMyStarBalanceWithContext(ctx context.Context) (StarAmount, er
 
 // GetStarTransactions returns Telegram Star transactions for the bot.
 // See https://core.telegram.org/bots/api#getstartransactions
-func (api *API) GetStarTransactions(params GetStarTransactionsP) (StarTransactions, error) {
+func (api *API) GetStarTransactions(params GetStarTransactions) (StarTransactions, error) {
 	req := NewRequest[StarTransactions]("getStarTransactions", params)
 	return req.Do(api)
 }
@@ -34,14 +34,14 @@ func (api *API) GetStarTransactions(params GetStarTransactionsP) (StarTransactio
 // GetStarTransactionsWithContext is the context-aware variant of GetStarTransactions.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#getstartransactions
-func (api *API) GetStarTransactionsWithContext(ctx context.Context, params GetStarTransactionsP) (StarTransactions, error) {
+func (api *API) GetStarTransactionsWithContext(ctx context.Context, params GetStarTransactions) (StarTransactions, error) {
 	req := NewRequest[StarTransactions]("getStarTransactions", params)
 	return req.DoWithContext(ctx, api)
 }
 
-// RefundStarPaymentP holds parameters for the refundStarPayment method.
+// RefundStarPayment holds parameters for the refundStarPayment method.
 // See https://core.telegram.org/bots/api#refundstarpayment
-type RefundStarPaymentP struct {
+type RefundStarPayment struct {
 	UserID                  int64  `json:"user_id"`
 	TelegramPaymentChargeID string `json:"telegram_payment_charge_id"`
 }
@@ -49,7 +49,7 @@ type RefundStarPaymentP struct {
 // RefundStarPayment refunds a successful Telegram Stars payment.
 // Returns true on success.
 // See https://core.telegram.org/bots/api#refundstarpayment
-func (api *API) RefundStarPayment(params RefundStarPaymentP) (bool, error) {
+func (api *API) RefundStarPayment(params RefundStarPayment) (bool, error) {
 	req := NewRequest[bool]("refundStarPayment", params)
 	return req.Do(api)
 }
@@ -57,14 +57,14 @@ func (api *API) RefundStarPayment(params RefundStarPaymentP) (bool, error) {
 // RefundStarPaymentWithContext is the context-aware variant of RefundStarPayment.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#refundstarpayment
-func (api *API) RefundStarPaymentWithContext(ctx context.Context, params RefundStarPaymentP) (bool, error) {
+func (api *API) RefundStarPaymentWithContext(ctx context.Context, params RefundStarPayment) (bool, error) {
 	req := NewRequest[bool]("refundStarPayment", params)
 	return req.DoWithContext(ctx, api)
 }
 
-// EditUserStarSubscriptionP holds parameters for the editUserStarSubscription method.
+// EditUserStarSubscription holds parameters for the editUserStarSubscription method.
 // See https://core.telegram.org/bots/api#edituserstarsubscription
-type EditUserStarSubscriptionP struct {
+type EditUserStarSubscription struct {
 	UserID                  int64  `json:"user_id"`
 	TelegramPaymentChargeID string `json:"telegram_payment_charge_id"`
 	IsCanceled              bool   `json:"is_canceled"`
@@ -73,7 +73,7 @@ type EditUserStarSubscriptionP struct {
 // EditUserStarSubscription cancels or re-enables a user star subscription extension.
 // Returns true on success.
 // See https://core.telegram.org/bots/api#edituserstarsubscription
-func (api *API) EditUserStarSubscription(params EditUserStarSubscriptionP) (bool, error) {
+func (api *API) EditUserStarSubscription(params EditUserStarSubscription) (bool, error) {
 	req := NewRequest[bool]("editUserStarSubscription", params)
 	return req.Do(api)
 }
@@ -81,7 +81,7 @@ func (api *API) EditUserStarSubscription(params EditUserStarSubscriptionP) (bool
 // EditUserStarSubscriptionWithContext is the context-aware variant of EditUserStarSubscription.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#edituserstarsubscription
-func (api *API) EditUserStarSubscriptionWithContext(ctx context.Context, params EditUserStarSubscriptionP) (bool, error) {
+func (api *API) EditUserStarSubscriptionWithContext(ctx context.Context, params EditUserStarSubscription) (bool, error) {
 	req := NewRequest[bool]("editUserStarSubscription", params)
 	return req.DoWithContext(ctx, api)
 }

tgapi/stickers_methods.go

@@ -2,9 +2,9 @@ package tgapi
 
 import "context"
 
-// SendStickerP holds parameters for the sendSticker method.
+// SendSticker holds parameters for the sendSticker method.
 // See https://core.telegram.org/bots/api#sendsticker
-type SendStickerP struct {
+type SendSticker struct {
 	BusinessConnectionID  string `json:"business_connection_id,omitempty"`
 	ChatID                int64  `json:"chat_id"`
 	MessageThreadID       int    `json:"message_thread_id,omitempty"`
@@ -24,7 +24,7 @@ type SendStickerP struct {
 
 // SendSticker sends a static .WEBP, animated .TGS, or video .WEBM sticker.
 // See https://core.telegram.org/bots/api#sendsticker
-func (api *API) SendSticker(params SendStickerP) (Message, error) {
+func (api *API) SendSticker(params SendSticker) (Message, error) {
 	req := NewRequestWithChatID[Message]("sendSticker", params, params.ChatID)
 	return req.Do(api)
 }
@@ -32,20 +32,20 @@ func (api *API) SendSticker(params SendStickerP) (Message, error) {
 // SendStickerWithContext is the context-aware variant of SendSticker.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#sendsticker
-func (api *API) SendStickerWithContext(ctx context.Context, params SendStickerP) (Message, error) {
+func (api *API) SendStickerWithContext(ctx context.Context, params SendSticker) (Message, error) {
 	req := NewRequestWithChatID[Message]("sendSticker", params, params.ChatID)
 	return req.DoWithContext(ctx, api)
 }
 
-// GetStickerSetP holds parameters for the getStickerSet method.
+// GetStickerSet holds parameters for the getStickerSet method.
 // See https://core.telegram.org/bots/api#getstickerset
-type GetStickerSetP struct {
+type GetStickerSet struct {
 	Name string `json:"name"`
 }
 
 // GetStickerSet returns a sticker set by its name.
 // See https://core.telegram.org/bots/api#getstickerset
-func (api *API) GetStickerSet(params GetStickerSetP) (StickerSet, error) {
+func (api *API) GetStickerSet(params GetStickerSet) (StickerSet, error) {
 	req := NewRequest[StickerSet]("getStickerSet", params)
 	return req.Do(api)
 }
@@ -53,20 +53,20 @@ func (api *API) GetStickerSet(params GetStickerSetP) (StickerSet, error) {
 // GetStickerSetWithContext is the context-aware variant of GetStickerSet.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#getstickerset
-func (api *API) GetStickerSetWithContext(ctx context.Context, params GetStickerSetP) (StickerSet, error) {
+func (api *API) GetStickerSetWithContext(ctx context.Context, params GetStickerSet) (StickerSet, error) {
 	req := NewRequest[StickerSet]("getStickerSet", params)
 	return req.DoWithContext(ctx, api)
 }
 
-// GetCustomEmojiStickersP holds parameters for the getCustomEmojiStickers method.
+// GetCustomEmojiStickers holds parameters for the getCustomEmojiStickers method.
 // See https://core.telegram.org/bots/api#getcustomemojistickers
-type GetCustomEmojiStickersP struct {
+type GetCustomEmojiStickers struct {
 	CustomEmojiIDs []string `json:"custom_emoji_ids"`
 }
 
 // GetCustomEmojiStickers returns information about custom emoji stickers by their IDs.
 // See https://core.telegram.org/bots/api#getcustomemojistickers
-func (api *API) GetCustomEmojiStickers(params GetCustomEmojiStickersP) ([]Sticker, error) {
+func (api *API) GetCustomEmojiStickers(params GetCustomEmojiStickers) ([]Sticker, error) {
 	req := NewRequest[[]Sticker]("getCustomEmojiStickers", params)
 	return req.Do(api)
 }
@@ -74,14 +74,14 @@ func (api *API) GetCustomEmojiStickers(params GetCustomEmojiStickersP) ([]Sticke
 // GetCustomEmojiStickersWithContext is the context-aware variant of GetCustomEmojiStickers.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#getcustomemojistickers
-func (api *API) GetCustomEmojiStickersWithContext(ctx context.Context, params GetCustomEmojiStickersP) ([]Sticker, error) {
+func (api *API) GetCustomEmojiStickersWithContext(ctx context.Context, params GetCustomEmojiStickers) ([]Sticker, error) {
 	req := NewRequest[[]Sticker]("getCustomEmojiStickers", params)
 	return req.DoWithContext(ctx, api)
 }
 
-// UploadStickerFileP holds parameters for the uploadStickerFile method.
+// UploadStickerFile holds parameters for the uploadStickerFile method.
 // See https://core.telegram.org/bots/api#uploadstickerfile
-type UploadStickerFileP struct {
+type UploadStickerFile struct {
 	UserID        int64              `json:"user_id"`
 	StickerFormat InputStickerFormat `json:"sticker_format"`
 }
@@ -89,7 +89,7 @@ type UploadStickerFileP struct {
 // UploadStickerFile uploads a sticker file for later use in sticker set methods.
 // sticker is the file to upload.
 // See https://core.telegram.org/bots/api#uploadstickerfile
-func (api *API) UploadStickerFile(params UploadStickerFileP, sticker UploaderFile) (File, error) {
+func (api *API) UploadStickerFile(params UploadStickerFile, sticker UploaderFile) (File, error) {
 	uploader := NewUploader(api)
 	defer func() {
 		_ = uploader.Close()
@@ -101,7 +101,7 @@ func (api *API) UploadStickerFile(params UploadStickerFileP, sticker UploaderFil
 // UploadStickerFileWithContext is the context-aware variant of UploadStickerFile.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#uploadstickerfile
-func (api *API) UploadStickerFileWithContext(ctx context.Context, params UploadStickerFileP, sticker UploaderFile) (File, error) {
+func (api *API) UploadStickerFileWithContext(ctx context.Context, params UploadStickerFile, sticker UploaderFile) (File, error) {
 	uploader := NewUploader(api)
 	defer func() {
 		_ = uploader.Close()
@@ -110,9 +110,9 @@ func (api *API) UploadStickerFileWithContext(ctx context.Context, params UploadS
 	return req.DoWithContext(ctx, uploader)
 }
 
-// CreateNewStickerSetP holds parameters for the createNewStickerSet method.
+// CreateNewStickerSet holds parameters for the createNewStickerSet method.
 // See https://core.telegram.org/bots/api#createnewstickerset
-type CreateNewStickerSetP struct {
+type CreateNewStickerSet struct {
 	UserID int64  `json:"user_id"`
 	Name   string `json:"name"`
 	Title  string `json:"title"`
@@ -125,7 +125,7 @@ type CreateNewStickerSetP struct {
 // CreateNewStickerSet creates a new sticker set owned by a user.
 // Returns True on success.
 // See https://core.telegram.org/bots/api#createnewstickerset
-func (api *API) CreateNewStickerSet(params CreateNewStickerSetP) (bool, error) {
+func (api *API) CreateNewStickerSet(params CreateNewStickerSet) (bool, error) {
 	req := NewRequest[bool]("createNewStickerSet", params)
 	return req.Do(api)
 }
@@ -133,14 +133,14 @@ func (api *API) CreateNewStickerSet(params CreateNewStickerSetP) (bool, error) {
 // CreateNewStickerSetWithContext is the context-aware variant of CreateNewStickerSet.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#createnewstickerset
-func (api *API) CreateNewStickerSetWithContext(ctx context.Context, params CreateNewStickerSetP) (bool, error) {
+func (api *API) CreateNewStickerSetWithContext(ctx context.Context, params CreateNewStickerSet) (bool, error) {
 	req := NewRequest[bool]("createNewStickerSet", params)
 	return req.DoWithContext(ctx, api)
 }
 
-// AddStickerToSetP holds parameters for the addStickerToSet method.
+// AddStickerToSet holds parameters for the addStickerToSet method.
 // See https://core.telegram.org/bots/api#addstickertoset
-type AddStickerToSetP struct {
+type AddStickerToSet struct {
 	UserID  int64        `json:"user_id"`
 	Name    string       `json:"name"`
 	Sticker InputSticker `json:"sticker"`
@@ -149,7 +149,7 @@ type AddStickerToSetP struct {
 // AddStickerToSet adds a new sticker to a set created by the bot.
 // Returns True on success.
 // See https://core.telegram.org/bots/api#addstickertoset
-func (api *API) AddStickerToSet(params AddStickerToSetP) (bool, error) {
+func (api *API) AddStickerToSet(params AddStickerToSet) (bool, error) {
 	req := NewRequest[bool]("addStickerToSet", params)
 	return req.Do(api)
 }
@@ -157,14 +157,14 @@ func (api *API) AddStickerToSet(params AddStickerToSetP) (bool, error) {
 // AddStickerToSetWithContext is the context-aware variant of AddStickerToSet.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#addstickertoset
-func (api *API) AddStickerToSetWithContext(ctx context.Context, params AddStickerToSetP) (bool, error) {
+func (api *API) AddStickerToSetWithContext(ctx context.Context, params AddStickerToSet) (bool, error) {
 	req := NewRequest[bool]("addStickerToSet", params)
 	return req.DoWithContext(ctx, api)
 }
 
-// SetStickerPositionInSetP holds parameters for the setStickerPositionInSet method.
+// SetStickerPositionInSet holds parameters for the setStickerPositionInSet method.
 // See https://core.telegram.org/bots/api#setstickerpositioninset
-type SetStickerPositionInSetP struct {
+type SetStickerPositionInSet struct {
 	Sticker  string `json:"sticker"`
 	Position int    `json:"position"`
 }
@@ -172,7 +172,7 @@ type SetStickerPositionInSetP struct {
 // SetStickerPositionInSet moves a sticker in a set to a specific position.
 // Returns True on success.
 // See https://core.telegram.org/bots/api#setstickerpositioninset
-func (api *API) SetStickerPositionInSet(params SetStickerPositionInSetP) (bool, error) {
+func (api *API) SetStickerPositionInSet(params SetStickerPositionInSet) (bool, error) {
 	req := NewRequest[bool]("setStickerPositionInSet", params)
 	return req.Do(api)
 }
@@ -180,21 +180,21 @@ func (api *API) SetStickerPositionInSet(params SetStickerPositionInSetP) (bool,
 // SetStickerPositionInSetWithContext is the context-aware variant of SetStickerPositionInSet.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#setstickerpositioninset
-func (api *API) SetStickerPositionInSetWithContext(ctx context.Context, params SetStickerPositionInSetP) (bool, error) {
+func (api *API) SetStickerPositionInSetWithContext(ctx context.Context, params SetStickerPositionInSet) (bool, error) {
 	req := NewRequest[bool]("setStickerPositionInSet", params)
 	return req.DoWithContext(ctx, api)
 }
 
-// DeleteStickerFromSetP holds parameters for the deleteStickerFromSet method.
+// DeleteStickerFromSet holds parameters for the deleteStickerFromSet method.
 // See https://core.telegram.org/bots/api#deletestickerfromset
-type DeleteStickerFromSetP struct {
+type DeleteStickerFromSet struct {
 	Sticker string `json:"sticker"`
 }
 
 // DeleteStickerFromSet deletes a sticker from a set created by the bot.
 // Returns True on success.
 // See https://core.telegram.org/bots/api#deletestickerfromset
-func (api *API) DeleteStickerFromSet(params DeleteStickerFromSetP) (bool, error) {
+func (api *API) DeleteStickerFromSet(params DeleteStickerFromSet) (bool, error) {
 	req := NewRequest[bool]("deleteStickerFromSet", params)
 	return req.Do(api)
 }
@@ -202,14 +202,14 @@ func (api *API) DeleteStickerFromSet(params DeleteStickerFromSetP) (bool, error)
 // DeleteStickerFromSetWithContext is the context-aware variant of DeleteStickerFromSet.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#deletestickerfromset
-func (api *API) DeleteStickerFromSetWithContext(ctx context.Context, params DeleteStickerFromSetP) (bool, error) {
+func (api *API) DeleteStickerFromSetWithContext(ctx context.Context, params DeleteStickerFromSet) (bool, error) {
 	req := NewRequest[bool]("deleteStickerFromSet", params)
 	return req.DoWithContext(ctx, api)
 }
 
-// ReplaceStickerInSetP holds parameters for the replaceStickerInSet method.
+// ReplaceStickerInSet holds parameters for the replaceStickerInSet method.
 // See https://core.telegram.org/bots/api#replacestickerinset
-type ReplaceStickerInSetP struct {
+type ReplaceStickerInSet struct {
 	UserID     int64        `json:"user_id"`
 	Name       string       `json:"name"`
 	OldSticker string       `json:"old_sticker"`
@@ -219,7 +219,7 @@ type ReplaceStickerInSetP struct {
 // ReplaceStickerInSet replaces an existing sticker in a set with a new one.
 // Returns True on success.
 // See https://core.telegram.org/bots/api#replacestickerinset
-func (api *API) ReplaceStickerInSet(params ReplaceStickerInSetP) (bool, error) {
+func (api *API) ReplaceStickerInSet(params ReplaceStickerInSet) (bool, error) {
 	req := NewRequest[bool]("replaceStickerInSet", params)
 	return req.Do(api)
 }
@@ -227,14 +227,14 @@ func (api *API) ReplaceStickerInSet(params ReplaceStickerInSetP) (bool, error) {
 // ReplaceStickerInSetWithContext is the context-aware variant of ReplaceStickerInSet.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#replacestickerinset
-func (api *API) ReplaceStickerInSetWithContext(ctx context.Context, params ReplaceStickerInSetP) (bool, error) {
+func (api *API) ReplaceStickerInSetWithContext(ctx context.Context, params ReplaceStickerInSet) (bool, error) {
 	req := NewRequest[bool]("replaceStickerInSet", params)
 	return req.DoWithContext(ctx, api)
 }
 
-// SetStickerEmojiListP holds parameters for the setStickerEmojiList method.
+// SetStickerEmojiList holds parameters for the setStickerEmojiList method.
 // See https://core.telegram.org/bots/api#setstickeremojilist
-type SetStickerEmojiListP struct {
+type SetStickerEmojiList struct {
 	Sticker   string   `json:"sticker"`
 	EmojiList []string `json:"emoji_list"`
 }
@@ -242,7 +242,7 @@ type SetStickerEmojiListP struct {
 // SetStickerEmojiList changes the list of emoji associated with a sticker.
 // Returns True on success.
 // See https://core.telegram.org/bots/api#setstickeremojilist
-func (api *API) SetStickerEmojiList(params SetStickerEmojiListP) (bool, error) {
+func (api *API) SetStickerEmojiList(params SetStickerEmojiList) (bool, error) {
 	req := NewRequest[bool]("setStickerEmojiList", params)
 	return req.Do(api)
 }
@@ -250,14 +250,14 @@ func (api *API) SetStickerEmojiList(params SetStickerEmojiListP) (bool, error) {
 // SetStickerEmojiListWithContext is the context-aware variant of SetStickerEmojiList.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#setstickeremojilist
-func (api *API) SetStickerEmojiListWithContext(ctx context.Context, params SetStickerEmojiListP) (bool, error) {
+func (api *API) SetStickerEmojiListWithContext(ctx context.Context, params SetStickerEmojiList) (bool, error) {
 	req := NewRequest[bool]("setStickerEmojiList", params)
 	return req.DoWithContext(ctx, api)
 }
 
-// SetStickerKeywordsP holds parameters for the setStickerKeywords method.
+// SetStickerKeywords holds parameters for the setStickerKeywords method.
 // See https://core.telegram.org/bots/api#setstickerkeywords
-type SetStickerKeywordsP struct {
+type SetStickerKeywords struct {
 	Sticker  string   `json:"sticker"`
 	Keywords []string `json:"keywords"`
 }
@@ -265,7 +265,7 @@ type SetStickerKeywordsP struct {
 // SetStickerKeywords changes the keywords of a sticker.
 // Returns True on success.
 // See https://core.telegram.org/bots/api#setstickerkeywords
-func (api *API) SetStickerKeywords(params SetStickerKeywordsP) (bool, error) {
+func (api *API) SetStickerKeywords(params SetStickerKeywords) (bool, error) {
 	req := NewRequest[bool]("setStickerKeywords", params)
 	return req.Do(api)
 }
@@ -273,14 +273,14 @@ func (api *API) SetStickerKeywords(params SetStickerKeywordsP) (bool, error) {
 // SetStickerKeywordsWithContext is the context-aware variant of SetStickerKeywords.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#setstickerkeywords
-func (api *API) SetStickerKeywordsWithContext(ctx context.Context, params SetStickerKeywordsP) (bool, error) {
+func (api *API) SetStickerKeywordsWithContext(ctx context.Context, params SetStickerKeywords) (bool, error) {
 	req := NewRequest[bool]("setStickerKeywords", params)
 	return req.DoWithContext(ctx, api)
 }
 
-// SetStickerMaskPositionP holds parameters for the setStickerMaskPosition method.
+// SetStickerMaskPosition holds parameters for the setStickerMaskPosition method.
 // See https://core.telegram.org/bots/api#setstickermaskposition
-type SetStickerMaskPositionP struct {
+type SetStickerMaskPosition struct {
 	Sticker      string        `json:"sticker"`
 	MaskPosition *MaskPosition `json:"mask_position,omitempty"`
 }
@@ -288,7 +288,7 @@ type SetStickerMaskPositionP struct {
 // SetStickerMaskPosition changes the mask position of a mask sticker.
 // Returns True on success.
 // See https://core.telegram.org/bots/api#setstickermaskposition
-func (api *API) SetStickerMaskPosition(params SetStickerMaskPositionP) (bool, error) {
+func (api *API) SetStickerMaskPosition(params SetStickerMaskPosition) (bool, error) {
 	req := NewRequest[bool]("setStickerMaskPosition", params)
 	return req.Do(api)
 }
@@ -296,14 +296,14 @@ func (api *API) SetStickerMaskPosition(params SetStickerMaskPositionP) (bool, er
 // SetStickerMaskPositionWithContext is the context-aware variant of SetStickerMaskPosition.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#setstickermaskposition
-func (api *API) SetStickerMaskPositionWithContext(ctx context.Context, params SetStickerMaskPositionP) (bool, error) {
+func (api *API) SetStickerMaskPositionWithContext(ctx context.Context, params SetStickerMaskPosition) (bool, error) {
 	req := NewRequest[bool]("setStickerMaskPosition", params)
 	return req.DoWithContext(ctx, api)
 }
 
-// SetStickerSetTitleP holds parameters for the setStickerSetTitle method.
+// SetStickerSetTitle holds parameters for the setStickerSetTitle method.
 // See https://core.telegram.org/bots/api#setstickersettitle
-type SetStickerSetTitleP struct {
+type SetStickerSetTitle struct {
 	Name  string `json:"name"`
 	Title string `json:"title"`
 }
@@ -311,7 +311,7 @@ type SetStickerSetTitleP struct {
 // SetStickerSetTitle sets the title of a sticker set created by the bot.
 // Returns True on success.
 // See https://core.telegram.org/bots/api#setstickersettitle
-func (api *API) SetStickerSetTitle(params SetStickerSetTitleP) (bool, error) {
+func (api *API) SetStickerSetTitle(params SetStickerSetTitle) (bool, error) {
 	req := NewRequest[bool]("setStickerSetTitle", params)
 	return req.Do(api)
 }
@@ -319,14 +319,14 @@ func (api *API) SetStickerSetTitle(params SetStickerSetTitleP) (bool, error) {
 // SetStickerSetTitleWithContext is the context-aware variant of SetStickerSetTitle.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#setstickersettitle
-func (api *API) SetStickerSetTitleWithContext(ctx context.Context, params SetStickerSetTitleP) (bool, error) {
+func (api *API) SetStickerSetTitleWithContext(ctx context.Context, params SetStickerSetTitle) (bool, error) {
 	req := NewRequest[bool]("setStickerSetTitle", params)
 	return req.DoWithContext(ctx, api)
 }
 
-// SetStickerSetThumbnailP holds parameters for the setStickerSetThumbnail method.
+// SetStickerSetThumbnail holds parameters for the setStickerSetThumbnail method.
 // See https://core.telegram.org/bots/api#setstickersetthumbnail
-type SetStickerSetThumbnailP struct {
+type SetStickerSetThumbnail struct {
 	Name      string             `json:"name"`
 	UserID    int64              `json:"user_id"`
 	Thumbnail string             `json:"thumbnail"`
@@ -336,7 +336,7 @@ type SetStickerSetThumbnailP struct {
 // SetStickerSetThumbnail sets the thumbnail of a sticker set.
 // Returns True on success.
 // See https://core.telegram.org/bots/api#setstickersetthumbnail
-func (api *API) SetStickerSetThumbnail(params SetStickerSetThumbnailP) (bool, error) {
+func (api *API) SetStickerSetThumbnail(params SetStickerSetThumbnail) (bool, error) {
 	req := NewRequest[bool]("setStickerSetThumbnail", params)
 	return req.Do(api)
 }
@@ -344,14 +344,14 @@ func (api *API) SetStickerSetThumbnail(params SetStickerSetThumbnailP) (bool, er
 // SetStickerSetThumbnailWithContext is the context-aware variant of SetStickerSetThumbnail.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#setstickersetthumbnail
-func (api *API) SetStickerSetThumbnailWithContext(ctx context.Context, params SetStickerSetThumbnailP) (bool, error) {
+func (api *API) SetStickerSetThumbnailWithContext(ctx context.Context, params SetStickerSetThumbnail) (bool, error) {
 	req := NewRequest[bool]("setStickerSetThumbnail", params)
 	return req.DoWithContext(ctx, api)
 }
 
-// SetCustomEmojiStickerSetThumbnailP holds parameters for the setCustomEmojiStickerSetThumbnail method.
+// SetCustomEmojiStickerSetThumbnail holds parameters for the setCustomEmojiStickerSetThumbnail method.
 // See https://core.telegram.org/bots/api#setcustomemojistickersetthumbnail
-type SetCustomEmojiStickerSetThumbnailP struct {
+type SetCustomEmojiStickerSetThumbnail struct {
 	Name          string `json:"name"`
 	CustomEmojiID string `json:"custom_emoji_id,omitempty"`
 }
@@ -359,7 +359,7 @@ type SetCustomEmojiStickerSetThumbnailP struct {
 // SetCustomEmojiStickerSetThumbnail sets the thumbnail of a custom emoji sticker set.
 // Returns True on success.
 // See https://core.telegram.org/bots/api#setcustomemojistickersetthumbnail
-func (api *API) SetCustomEmojiStickerSetThumbnail(params SetCustomEmojiStickerSetThumbnailP) (bool, error) {
+func (api *API) SetCustomEmojiStickerSetThumbnail(params SetCustomEmojiStickerSetThumbnail) (bool, error) {
 	req := NewRequest[bool]("setCustomEmojiStickerSetThumbnail", params)
 	return req.Do(api)
 }
@@ -367,21 +367,21 @@ func (api *API) SetCustomEmojiStickerSetThumbnail(params SetCustomEmojiStickerSe
 // SetCustomEmojiStickerSetThumbnailWithContext is the context-aware variant of SetCustomEmojiStickerSetThumbnail.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#setcustomemojistickersetthumbnail
-func (api *API) SetCustomEmojiStickerSetThumbnailWithContext(ctx context.Context, params SetCustomEmojiStickerSetThumbnailP) (bool, error) {
+func (api *API) SetCustomEmojiStickerSetThumbnailWithContext(ctx context.Context, params SetCustomEmojiStickerSetThumbnail) (bool, error) {
 	req := NewRequest[bool]("setCustomEmojiStickerSetThumbnail", params)
 	return req.DoWithContext(ctx, api)
 }
 
-// DeleteStickerSetP holds parameters for the deleteStickerSet method.
+// DeleteStickerSet holds parameters for the deleteStickerSet method.
 // See https://core.telegram.org/bots/api#deletestickerset
-type DeleteStickerSetP struct {
+type DeleteStickerSet struct {
 	Name string `json:"name"`
 }
 
 // DeleteStickerSet deletes a sticker set created by the bot.
 // Returns True on success.
 // See https://core.telegram.org/bots/api#deletestickerset
-func (api *API) DeleteStickerSet(params DeleteStickerSetP) (bool, error) {
+func (api *API) DeleteStickerSet(params DeleteStickerSet) (bool, error) {
 	req := NewRequest[bool]("deleteStickerSet", params)
 	return req.Do(api)
 }
@@ -389,7 +389,7 @@ func (api *API) DeleteStickerSet(params DeleteStickerSetP) (bool, error) {
 // DeleteStickerSetWithContext is the context-aware variant of DeleteStickerSet.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#deletestickerset
-func (api *API) DeleteStickerSetWithContext(ctx context.Context, params DeleteStickerSetP) (bool, error) {
+func (api *API) DeleteStickerSetWithContext(ctx context.Context, params DeleteStickerSet) (bool, error) {
 	req := NewRequest[bool]("deleteStickerSet", params)
 	return req.DoWithContext(ctx, api)
 }

tgapi/stickers_types.go

@@ -38,8 +38,8 @@ const (
 // Sticker represents a sticker.
 // See https://core.telegram.org/bots/api#sticker
 type Sticker struct {
-	FileId       string      `json:"file_id"`
-	FileUniqueId string      `json:"file_unique_id"`
+	FileID       string      `json:"file_id"`
+	FileUniqueID string      `json:"file_unique_id"`
 	Type         StickerType `json:"type"`
 	Width        int         `json:"width"`
 	Height       int         `json:"height"`

tgapi/types.go

@@ -57,6 +57,8 @@ const (
 	UpdateTypeChatBoost UpdateType = "chat_boost"
 	// UpdateTypeRemovedChatBoost is a removed chat boost update.
 	UpdateTypeRemovedChatBoost UpdateType = "removed_chat_boost"
+
+	UpdateTypeManagedBot UpdateType = "managed_bot"
 )
 
 // Update represents an incoming update from Telegram.
@@ -91,6 +93,8 @@ type Update struct {
 	ChatJoinRequest  *ChatJoinRequest   `json:"chat_join_request,omitempty"`
 	ChatBoost        *ChatBoostUpdated  `json:"chat_boost,omitempty"`
 	RemovedChatBoost *ChatBoostRemoved  `json:"removed_chat_boost,omitempty"`
+
+	ManagedBot *ManagedBotUpdated `json:"managed_bot,omitempty"`
 }
 
 // UnmarshalJSON decodes an update and derives its Type from the populated payload field.
@@ -154,6 +158,8 @@ func (u *Update) UnmarshalJSON(data []byte) error {
 		u.Type = UpdateTypeChatBoost
 	case u.RemovedChatBoost != nil:
 		u.Type = UpdateTypeRemovedChatBoost
+	case u.ManagedBot != nil:
+		u.Type = UpdateTypeManagedBot
 	default:
 		u.Type = UpdateTypeUnknown
 	}
@@ -161,6 +167,26 @@ func (u *Update) UnmarshalJSON(data []byte) error {
 	return nil
 }
 
+// WebhookInfo describes the current webhook status.
+// See https://core.telegram.org/bots/api#webhookinfo
+type WebhookInfo struct {
+	URL                          string   `json:"url"`
+	HasCustomCertificate         bool     `json:"has_custom_certificate"`
+	PendingUpdateCount           int      `json:"pending_update_count"`
+	IPAddress                    string   `json:"ip_address,omitempty"`
+	LastErrorDate                int      `json:"last_error_date,omitempty"`
+	LastErrorMessage             string   `json:"last_error_message,omitempty"`
+	LastSynchronizationErrorDate int      `json:"last_synchronization_error_date,omitempty"`
+	MaxConnections               int      `json:"max_connections,omitempty"`
+	AllowedUpdates               []string `json:"allowed_updates,omitempty"`
+}
+
+type ProximityAlertTriggered struct {
+	Traveler User `json:"traveler"`
+	Watcher  User `json:"watcher"`
+	Distance int  `json:"distance"`
+}
+
 // InlineQuery represents an incoming inline query.
 // See https://core.telegram.org/bots/api#inlinequery
 type InlineQuery struct {
@@ -182,115 +208,15 @@ type ChosenInlineResult struct {
 	Query           string    `json:"query"`
 }
 
-// ShippingQuery represents an incoming shipping query.
-// See https://core.telegram.org/bots/api#shippingquery
-type ShippingQuery struct {
-	ID              string          `json:"id"`
-	From            User            `json:"from"`
-	InvoicePayload  string          `json:"invoice_payload"`
-	ShippingAddress ShippingAddress `json:"shipping_address"`
-}
-
-// ShippingAddress represents a shipping address.
-// See https://core.telegram.org/bots/api#shippingaddress
-type ShippingAddress struct {
-	CountryCode string `json:"country_code"`
-	State       string `json:"state"`
-	City        string `json:"city"`
-	StreetLine1 string `json:"street_line1"`
-	StreetLine2 string `json:"street_line2"`
-	PostCode    string `json:"post_code"`
-}
-
-// OrderInfo represents information about an order.
-// See https://core.telegram.org/bots/api#orderinfo
-type OrderInfo struct {
-	Name            string          `json:"name"`
-	PhoneNumber     string          `json:"phone_number"`
-	Email           string          `json:"email"`
-	ShippingAddress ShippingAddress `json:"shipping_address"`
-}
-
-// PreCheckoutQuery represents an incoming pre-checkout query.
-// See https://core.telegram.org/bots/api#precheckoutquery
-type PreCheckoutQuery struct {
-	ID               string     `json:"id"`
-	From             User       `json:"from"`
-	Currency         string     `json:"currency"`
-	TotalAmount      int        `json:"total_amount"`
-	InvoicePayload   string     `json:"invoice_payload"`
-	ShippingOptionID string     `json:"shipping_option_id"`
-	OrderInfo        *OrderInfo `json:"order_info,omitempty"`
-}
-
-// PaidMediaPurchased represents a purchased paid media.
-// See https://core.telegram.org/bots/api#paidmediapurchased
-type PaidMediaPurchased struct {
-	From             User   `json:"from"`
-	PaidMediaPayload string `json:"paid_media_payload"`
-}
-
 // File represents a file ready to be downloaded.
 // See https://core.telegram.org/bots/api#file
 type File struct {
-	FileId       string `json:"file_id"`
+	FileID       string `json:"file_id"`
 	FileUniqueID string `json:"file_unique_id"`
 	FileSize     int64  `json:"file_size,omitempty"`
 	FilePath     string `json:"file_path,omitempty"`
 }
 
-// Audio represents an audio file to be treated as music by the Telegram clients.
-// See https://core.telegram.org/bots/api#audio
-type Audio struct {
-	FileID       string `json:"file_id"`
-	FileUniqueID string `json:"file_unique_id"`
-	Duration     int    `json:"duration"`
-
-	Performer string     `json:"performer,omitempty"`
-	Title     string     `json:"title,omitempty"`
-	FileName  string     `json:"file_name,omitempty"`
-	MimeType  string     `json:"mime_type,omitempty"`
-	FileSize  int64      `json:"file_size,omitempty"`
-	Thumbnail *PhotoSize `json:"thumbnail,omitempty"`
-}
-
-// PollOption contains information about one answer option in a poll.
-// See https://core.telegram.org/bots/api#polloption
-type PollOption struct {
-	Text         string          `json:"text"`
-	TextEntities []MessageEntity `json:"text_entities"`
-	VoterCount   int             `json:"voter_count"`
-}
-
-// Poll contains information about a poll.
-// See https://core.telegram.org/bots/api#poll
-type Poll struct {
-	ID               string          `json:"id"`
-	Question         string          `json:"question"`
-	QuestionEntities []MessageEntity `json:"question_entities"`
-	Options          []PollOption    `json:"options"`
-	TotalVoterCount  int             `json:"total_voter_count"`
-	IsClosed         bool            `json:"is_closed"`
-	IsAnonymous      bool            `json:"is_anonymous"`
-	Type             PollType        `json:"type"`
-
-	AllowsMultipleAnswers bool            `json:"allows_multiple_answers"`
-	CorrectOptionID       *int            `json:"correct_option_id,omitempty"`
-	Explanation           *string         `json:"explanation,omitempty"`
-	ExplanationEntities   []MessageEntity `json:"explanation_entities,omitempty"`
-	OpenPeriod            int             `json:"open_period,omitempty"`
-	CloseDate             int             `json:"close_date,omitempty"`
-}
-
-// PollAnswer represents an answer of a user in a poll.
-// See https://core.telegram.org/bots/api#pollanswer
-type PollAnswer struct {
-	PollID    string `json:"poll_id"`
-	VoterChat Chat   `json:"voter_chat"`
-	User      User   `json:"user"`
-	OptionIDS []int  `json:"option_ids"`
-}
-
 // ChatMemberUpdated represents changes in the status of a chat member.
 // See https://core.telegram.org/bots/api#chatmemberupdated
 type ChatMemberUpdated struct {
@@ -352,18 +278,17 @@ type WebAppInfo struct {
 	URL string `json:"url"`
 }
 
+type WebAppData struct {
+	Data       string `json:"data"`
+	ButtonText string `json:"button_text"`
+}
+
 // StarAmount represents an amount of Telegram Stars.
 type StarAmount struct {
 	Amount         int `json:"amount"`
 	NanostarAmount int `json:"nanostar_amount"`
 }
 
-// Story represents a story.
-type Story struct {
-	Chat Chat `json:"chat"`
-	ID   int  `json:"id"`
-}
-
 // AcceptedGiftTypes represents the types of gifts accepted by a user or chat.
 type AcceptedGiftTypes struct {
 	UnlimitedGifts      bool `json:"unlimited_gifts"`
@@ -373,16 +298,6 @@ type AcceptedGiftTypes struct {
 	GiftsFromChannels   bool `json:"gifts_from_channels"`
 }
 
-// UniqueGiftColors represents color information for a unique gift.
-type UniqueGiftColors struct {
-	ModelCustomEmojiID    string `json:"model_custom_emoji_id"`
-	SymbolCustomEmojiID   string `json:"symbol_custom_emoji_id"`
-	LightThemeMainColor   int    `json:"light_theme_main_color"`
-	LightThemeOtherColors []int  `json:"light_theme_other_colors"`
-	DarkThemeMainColor    int    `json:"dark_theme_main_color"`
-	DarkThemeOtherColors  []int  `json:"dark_theme_other_colors"`
-}
-
 // GiftBackground represents the background of a gift.
 type GiftBackground struct {
 	CenterColor int `json:"center_color"`
@@ -412,6 +327,78 @@ type Gifts struct {
 	Gifts []Gift `json:"gifts"`
 }
 
+type UniqueGiftModel struct {
+	Name           string  `json:"name"`
+	Sticker        Sticker `json:"sticker"`
+	RarityPerMille int     `json:"rarity_per_mille"`
+	Rarity         string  `json:"rarity,omitempty"`
+}
+type UniqueGiftSymbol struct {
+	Name           string  `json:"name"`
+	Sticker        Sticker `json:"sticker"`
+	RarityPerMille int     `json:"rarity_per_mille"`
+}
+type UniqueGiftBackdropColors struct {
+	CenterColor int `json:"center_color"`
+	EdgeColor   int `json:"edge_color"`
+	SymbolColor int `json:"symbol_color"`
+	TextColor   int `json:"text_color"`
+}
+type UniqueGiftBackdrop struct {
+	Name           string                   `json:"name"`
+	Colors         UniqueGiftBackdropColors `json:"colors"`
+	RarityPerMille int                      `json:"rarity_per_mille"`
+}
+
+// UniqueGiftColors represents color information for a unique gift.
+type UniqueGiftColors struct {
+	ModelCustomEmojiID    string `json:"model_custom_emoji_id"`
+	SymbolCustomEmojiID   string `json:"symbol_custom_emoji_id"`
+	LightThemeMainColor   int    `json:"light_theme_main_color"`
+	LightThemeOtherColors []int  `json:"light_theme_other_colors"`
+	DarkThemeMainColor    int    `json:"dark_theme_main_color"`
+	DarkThemeOtherColors  []int  `json:"dark_theme_other_colors"`
+}
+
+type UniqueGift struct {
+	GiftID   string             `json:"gift_id"`
+	BaseName string             `json:"base_name"`
+	Name     string             `json:"name"`
+	Number   int                `json:"number"`
+	Model    UniqueGiftModel    `json:"model"`
+	Symbol   UniqueGiftSymbol   `json:"symbol"`
+	Backdrop UniqueGiftBackdrop `json:"backdrop"`
+
+	IsPremium        bool              `json:"is_premium,omitempty"`
+	IsBurned         bool              `json:"is_burned,omitempty"`
+	IsFromBlockchain bool              `json:"is_from_blockchain,omitempty"`
+	Colors           *UniqueGiftColors `json:"colors,omitempty"`
+	PublisherChat    *Chat             `json:"publisher_chat,omitempty"`
+}
+
+type GiftInfo struct {
+	Gift Gift `json:"gift"`
+
+	OwnedGiftID             string          `json:"owned_gift_id,omitempty"`
+	ConvertStarCount        int             `json:"convert_star_count,omitempty"`
+	PrepaidUpgradeStarCount int             `json:"prepaid_upgrade_star_count,omitempty"`
+	IsUpgradeSeparate       bool            `json:"is_upgrade_separate,omitempty"`
+	CanBeUpgraded           bool            `json:"can_be_upgraded,omitempty"`
+	Text                    string          `json:"text,omitempty"`
+	Entities                []MessageEntity `json:"entities,omitempty"`
+	IsPrivate               bool            `json:"is_private,omitempty"`
+	UniqueGiftNumber        int             `json:"unique_gift_number,omitempty"`
+}
+type UniqueGiftInfo struct {
+	Gift               UniqueGift `json:"gift"`
+	Origin             string     `json:"origin"`
+	LastResaleCurrency string     `json:"last_resale_currency,omitempty"`
+	LastResaleAmount   int        `json:"last_resale_amount,omitempty"`
+	OwnedGiftID        string     `json:"owned_gift_id,omitempty"`
+	TransferStarCount  int        `json:"transfer_star_count,omitempty"`
+	NextTransferDate   int        `json:"next_transfer_date,omitempty"`
+}
+
 // OwnedGiftType represents the type of an owned gift.
 type OwnedGiftType string
 
@@ -425,27 +412,27 @@ const (
 // OwnedGift represents a gift owned by a user or chat.
 type OwnedGift struct {
 	Type        OwnedGiftType `json:"type"`
-	OwnerGiftID *string       `json:"owner_gift_id,omitempty"`
-	SendDate    *int          `json:"send_date,omitempty"`
-	IsSaved     *bool         `json:"is_saved,omitempty"`
+	OwnedGiftID string        `json:"ownen_gift_id,omitempty"`
+	SendDate    int           `json:"send_date,omitempty"`
+	IsSaved     bool          `json:"is_saved,omitempty"`
 
 	// Fields specific to "regular" type
 	Gift                    Gift            `json:"gift"`
 	SenderUser              *User           `json:"sender_user,omitempty"`
 	Text                    string          `json:"text,omitempty"`
 	Entities                []MessageEntity `json:"entities,omitempty"`
-	IsPrivate               *bool           `json:"is_private,omitempty"`
-	CanBeUpgraded           *bool           `json:"can_be_upgraded,omitempty"`
-	WasRefunded             *bool           `json:"was_refunded,omitempty"`
-	ConvertStarCount        *int            `json:"convert_star_count,omitempty"`
-	PrepaidUpgradeStarCount *int            `json:"prepaid_upgrade_star_count,omitempty"`
-	IsUpgradeSeparate       *bool           `json:"is_upgrade_separate,omitempty"`
-	UniqueGiftNumber        *int            `json:"unique_gift_number,omitempty"`
+	IsPrivate               bool            `json:"is_private,omitempty"`
+	CanBeUpgraded           bool            `json:"can_be_upgraded,omitempty"`
+	WasRefunded             bool            `json:"was_refunded,omitempty"`
+	ConvertStarCount        int             `json:"convert_star_count,omitempty"`
+	PrepaidUpgradeStarCount int             `json:"prepaid_upgrade_star_count,omitempty"`
+	IsUpgradeSeparate       bool            `json:"is_upgrade_separate,omitempty"`
+	UniqueGiftNumber        int             `json:"unique_gift_number,omitempty"`
 
 	// Fields specific to "unique" type
-	CanBeTransferred  *bool `json:"can_be_transferred,omitempty"`
-	TransferStarCount *int  `json:"transfer_star_count,omitempty"`
-	NextTransferDate  *int  `json:"next_transfer_date,omitempty"`
+	CanBeTransferred  bool `json:"can_be_transferred,omitempty"`
+	TransferStarCount int  `json:"transfer_star_count,omitempty"`
+	NextTransferDate  int  `json:"next_transfer_date,omitempty"`
 }
 
 // OwnedGifts represents a list of owned gifts with pagination.
@@ -454,3 +441,94 @@ type OwnedGifts struct {
 	Gifts      []OwnedGift `json:"gifts"`
 	NextOffset string      `json:"next_offset"`
 }
+
+type GiveawayCreated struct {
+	PrizeStarCount int `json:"prize_star_count,omitempty"`
+}
+
+type Giveaway struct {
+	Chats                []Chat `json:"chats"`
+	WinnersSelectionDate int    `json:"winners_selection_date"`
+	WinnerCount          int    `json:"winner_count"`
+
+	OnlyNewMembers                bool     `json:"only_new_members,omitempty"`
+	HasPublicWinners              bool     `json:"has_public_winners,omitempty"`
+	PrizeDescription              string   `json:"prize_description,omitempty"`
+	CountryCodes                  []string `json:"country_codes,omitempty"`
+	PrizeStarCount                int      `json:"prize_star_count,omitempty"`
+	PremiumSubscriptionMonthCount int      `json:"premium_subscription_month_count,omitempty"`
+}
+
+type GiveawayWinners struct {
+	Chat                 Chat   `json:"chat"`
+	GiveawayMessageID    int    `json:"giveaway_message_id"`
+	WinnersSelectionDate int    `json:"winners_selection_date"`
+	WinnerCount          int    `json:"winner_count"`
+	Winners              []User `json:"winners"`
+
+	AdditionalChatCount           int    `json:"additional_chat_count,omitempty"`
+	PrizeStarCount                int    `json:"prize_star_count,omitempty"`
+	PremiumSubscriptionMonthCount int    `json:"premium_subscription_month_count,omitempty"`
+	UnclaimedPrizeCount           int    `json:"unclaimed_prize_count,omitempty"`
+	OnlyNewMembers                bool   `json:"only_new_members,omitempty"`
+	WasRefunded                   bool   `json:"was_refunded,omitempty"`
+	PrizeDescription              string `json:"prize_description,omitempty"`
+}
+
+type GiveawayCompleted struct {
+	WinnerCount         int      `json:"winner_count"`
+	UnclaimedPrizeCount int      `json:"unclaimed_prize_count,omitempty"`
+	GiveawayMessage     *Message `json:"giveaway_message,omitempty"`
+	IsStarGiveaway      bool     `json:"is_star_giveaway,omitempty"`
+}
+
+type WriteAccessAllowed struct {
+	FromRequest        bool   `json:"from_request,omitempty"`
+	WebAppName         string `json:"web_app_name,omitempty"`
+	FromAttachmentMenu bool   `json:"from_attachment_menu,omitempty"`
+}
+
+type BackgroundFillType string
+
+const (
+	BackgroundFillSolidType            BackgroundFillType = "solid"
+	BackgroundFillGradientType         BackgroundFillType = "gradient"
+	BackgroundFillFreeformGradientType BackgroundFillType = "freeform_gradient"
+)
+
+type BackgroundFill struct {
+	Type BackgroundFillType `json:"type"`
+
+	Color int `json:"color,omitempty"`
+
+	TopColor      int `json:"top_color,omitempty"`
+	BottomColor   int `json:"bottom_color,omitempty"`
+	RotationAngle int `json:"rotation_angle,omitempty"`
+
+	Colors []int `json:"colors,omitempty"`
+}
+
+type BackgroundTypeType string
+
+const (
+	BackgroundTypeFillType      BackgroundTypeType = "fill"
+	BackgroundTypeWallpaperType BackgroundTypeType = "wallpaper"
+	BackgroundTypePatternType   BackgroundTypeType = "pattern"
+	BackgroundTypeChatThemeType BackgroundTypeType = "chat_theme"
+)
+
+type BackgroundType struct {
+	Type BackgroundTypeType `json:"type"`
+
+	Fill             *BackgroundFill `json:"fill,omitempty"`
+	DarkThemeDimming int             `json:"dark_theme_dimming,omitempty"`
+
+	Document  *Document `json:"document,omitempty"`
+	IsBlurred bool      `json:"is_blurred,omitempty"`
+	IsMoving  bool      `json:"is_moving,omitempty"`
+
+	Intensity  int  `json:"intensity,omitempty"`
+	IsInverted bool `json:"is_inverted,omitempty"`
+
+	ThemeName string `json:"theme_name,omitempty"`
+}

tgapi/types_test.go

@@ -61,6 +61,17 @@ func TestUpdateUnmarshalSetsType(t *testing.T) {
 			body: `{"update_id":4}`,
 			want: UpdateTypeUnknown,
 		},
+		{
+			name: "managed bot",
+			body: `{
+				"update_id": 5,
+				"managed_bot": {
+					"user": {"id": 11, "is_bot": false, "first_name": "Manager"},
+					"bot": {"id": 12, "is_bot": true, "first_name": "Worker"}
+				}
+			}`,
+			want: UpdateTypeManagedBot,
+		},
 	}
 
 	for _, tt := range tests {
@@ -75,10 +86,41 @@ func TestUpdateUnmarshalSetsType(t *testing.T) {
 			if tt.want == UpdateTypeChatBoost && update.ChatBoost.Boost.BoostID != "boost-1" {
 				t.Fatalf("unexpected boost id: got %q want %q", update.ChatBoost.Boost.BoostID, "boost-1")
 			}
+			if tt.want == UpdateTypeManagedBot && update.ManagedBot.Bot.ID != 12 {
+				t.Fatalf("unexpected managed bot id: got %d want %d", update.ManagedBot.Bot.ID, 12)
+			}
 		})
 	}
 }
 
+func TestPollUnmarshalSupportsBotAPI96Fields(t *testing.T) {
+	var poll Poll
+
+	body := `{
+		"id": "poll-1",
+		"question": "Pick winners",
+		"question_entities": [],
+		"options": [],
+		"total_voter_count": 2,
+		"is_closed": false,
+		"is_anonymous": false,
+		"type": "quiz",
+		"allows_multiple_answers": true,
+		"allows_revoting": true,
+		"correct_option_ids": [1, 3]
+	}`
+
+	if err := json.Unmarshal([]byte(body), &poll); err != nil {
+		t.Fatalf("Unmarshal returned error: %v", err)
+	}
+	if !poll.AllowsRevoting {
+		t.Fatal("expected allows_revoting to be decoded")
+	}
+	if len(poll.CorrectOptionIDs) != 2 || poll.CorrectOptionIDs[0] != 1 || poll.CorrectOptionIDs[1] != 3 {
+		t.Fatalf("unexpected correct option ids: %#v", poll.CorrectOptionIDs)
+	}
+}
+
 func TestUpdateMarshalOmitsSyntheticTypeField(t *testing.T) {
 	update := Update{
 		UpdateID: 1,
@@ -114,3 +156,62 @@ func TestUpdateShippingQueryIsNilWhenAbsent(t *testing.T) {
 		t.Fatalf("expected UpdateTypeUnknown, got %q", update.Type)
 	}
 }
+
+func TestMaybeInaccessibleMessageUnmarshalAccessibleMessage(t *testing.T) {
+	var wrapper MaybeInaccessibleMessage
+
+	body := `{
+		"message_id": 10,
+		"date": 1700000000,
+		"chat": {"id": 42, "type": "private"},
+		"text": "hello"
+	}`
+
+	if err := json.Unmarshal([]byte(body), &wrapper); err != nil {
+		t.Fatalf("Unmarshal returned error: %v", err)
+	}
+	if !wrapper.IsAccessible() {
+		t.Fatal("expected accessible message payload")
+	}
+	if wrapper.IsInaccessible() {
+		t.Fatal("expected inaccessible payload to be empty")
+	}
+	if wrapper.Message() == nil || wrapper.Message().Text != "hello" {
+		t.Fatalf("unexpected accessible payload: %#v", wrapper.Message())
+	}
+	if wrapper.MessageID() != 10 {
+		t.Fatalf("unexpected message id: got %d want %d", wrapper.MessageID(), 10)
+	}
+	if wrapper.Chat() == nil || wrapper.Chat().ID != 42 {
+		t.Fatalf("unexpected chat payload: %#v", wrapper.Chat())
+	}
+}
+
+func TestMaybeInaccessibleMessageUnmarshalInaccessibleMessage(t *testing.T) {
+	var wrapper MaybeInaccessibleMessage
+
+	body := `{
+		"message_id": 7,
+		"date": 0,
+		"chat": {"id": -1001, "type": "supergroup"}
+	}`
+
+	if err := json.Unmarshal([]byte(body), &wrapper); err != nil {
+		t.Fatalf("Unmarshal returned error: %v", err)
+	}
+	if wrapper.IsAccessible() {
+		t.Fatal("expected accessible payload to be empty")
+	}
+	if !wrapper.IsInaccessible() {
+		t.Fatal("expected inaccessible message payload")
+	}
+	if wrapper.InaccessibleMessage() == nil || wrapper.InaccessibleMessage().MessageID != 7 {
+		t.Fatalf("unexpected inaccessible payload: %#v", wrapper.InaccessibleMessage())
+	}
+	if wrapper.MessageID() != 7 {
+		t.Fatalf("unexpected message id: got %d want %d", wrapper.MessageID(), 7)
+	}
+	if wrapper.Chat() == nil || wrapper.Chat().ID != -1001 {
+		t.Fatalf("unexpected chat payload: %#v", wrapper.Chat())
+	}
+}

tgapi/uploader_api.go

@@ -71,6 +71,11 @@ type Uploader struct {
 // NewUploader creates a multipart uploader bound to an API client.
 func NewUploader(api *API) *Uploader {
 	logger := utils.CreateLogger("UPLOADER", utils.GetLoggerLevel())
+	if api == nil {
+		logger.Errorln("api is nil")
+		_ = logger.Close()
+		return nil
+	}
 	return &Uploader{api, logger}
 }
 

tgapi/uploader_api_test.go

@@ -57,7 +57,7 @@ func TestUploaderEncodesJSONFieldsAndLeavesAcceptEncodingToHTTPTransport(t *test
 	}()
 
 	msg, err := uploader.SendPhoto(
-		UploadPhotoP{
+		UploadPhoto{
 			ChatID: 42,
 			CaptionEntities: []MessageEntity{{
 				Type:   MessageEntityBold,

tgapi/uploader_methods.go

@@ -2,9 +2,9 @@ package tgapi
 
 import "context"
 
-// UploadPhotoP holds parameters for uploading a photo using the Uploader.
+// UploadPhoto holds parameters for uploading a photo using the Uploader.
 // See https://core.telegram.org/bots/api#sendphoto
-type UploadPhotoP struct {
+type UploadPhoto struct {
 	BusinessConnectionID  string `json:"business_connection_id,omitempty"`
 	ChatID                int64  `json:"chat_id"`
 	MessageThreadID       int    `json:"message_thread_id,omitempty"`
@@ -29,7 +29,7 @@ type UploadPhotoP struct {
 // SendPhoto uploads a photo via multipart and sends it as a message.
 // file is the photo file to upload.
 // See https://core.telegram.org/bots/api#sendphoto
-func (u *Uploader) SendPhoto(params UploadPhotoP, file UploaderFile) (Message, error) {
+func (u *Uploader) SendPhoto(params UploadPhoto, file UploaderFile) (Message, error) {
 	req := NewUploaderRequestWithChatID[Message]("sendPhoto", params, params.ChatID, file)
 	return req.Do(u)
 }
@@ -39,14 +39,14 @@ func (u *Uploader) SendPhoto(params UploadPhotoP, file UploaderFile) (Message, e
 // SendPhotoWithContext is the context-aware variant of SendPhoto.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#sendphoto
-func (u *Uploader) SendPhotoWithContext(ctx context.Context, params UploadPhotoP, file UploaderFile) (Message, error) {
+func (u *Uploader) SendPhotoWithContext(ctx context.Context, params UploadPhoto, file UploaderFile) (Message, error) {
 	req := NewUploaderRequestWithChatID[Message]("sendPhoto", params, params.ChatID, file)
 	return req.DoWithContext(ctx, u)
 }
 
-// UploadAudioP holds parameters for uploading an audio file using the Uploader.
+// UploadAudio holds parameters for uploading an audio file using the Uploader.
 // See https://core.telegram.org/bots/api#sendaudio
-type UploadAudioP struct {
+type UploadAudio struct {
 	BusinessConnectionID  string `json:"business_connection_id,omitempty"`
 	ChatID                int64  `json:"chat_id"`
 	MessageThreadID       int    `json:"message_thread_id,omitempty"`
@@ -73,7 +73,7 @@ type UploadAudioP struct {
 // SendAudio uploads an audio file via multipart and sends it as a message.
 // files are the audio file(s) to upload (typically one file).
 // See https://core.telegram.org/bots/api#sendaudio
-func (u *Uploader) SendAudio(params UploadAudioP, files ...UploaderFile) (Message, error) {
+func (u *Uploader) SendAudio(params UploadAudio, files ...UploaderFile) (Message, error) {
 	req := NewUploaderRequestWithChatID[Message]("sendAudio", params, params.ChatID, files...)
 	return req.Do(u)
 }
@@ -83,14 +83,14 @@ func (u *Uploader) SendAudio(params UploadAudioP, files ...UploaderFile) (Messag
 // SendAudioWithContext is the context-aware variant of SendAudio.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#sendaudio
-func (u *Uploader) SendAudioWithContext(ctx context.Context, params UploadAudioP, files ...UploaderFile) (Message, error) {
+func (u *Uploader) SendAudioWithContext(ctx context.Context, params UploadAudio, files ...UploaderFile) (Message, error) {
 	req := NewUploaderRequestWithChatID[Message]("sendAudio", params, params.ChatID, files...)
 	return req.DoWithContext(ctx, u)
 }
 
-// UploadDocumentP holds parameters for uploading a document using the Uploader.
+// UploadDocument holds parameters for uploading a document using the Uploader.
 // See https://core.telegram.org/bots/api#senddocument
-type UploadDocumentP struct {
+type UploadDocument struct {
 	BusinessConnectionID  string `json:"business_connection_id,omitempty"`
 	ChatID                int64  `json:"chat_id"`
 	MessageThreadID       int    `json:"message_thread_id,omitempty"`
@@ -114,7 +114,7 @@ type UploadDocumentP struct {
 // SendDocument uploads a document via multipart and sends it as a message.
 // files are the document file(s) to upload (typically one file).
 // See https://core.telegram.org/bots/api#senddocument
-func (u *Uploader) SendDocument(params UploadDocumentP, files ...UploaderFile) (Message, error) {
+func (u *Uploader) SendDocument(params UploadDocument, files ...UploaderFile) (Message, error) {
 	req := NewUploaderRequestWithChatID[Message]("sendDocument", params, params.ChatID, files...)
 	return req.Do(u)
 }
@@ -124,14 +124,14 @@ func (u *Uploader) SendDocument(params UploadDocumentP, files ...UploaderFile) (
 // SendDocumentWithContext is the context-aware variant of SendDocument.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#senddocument
-func (u *Uploader) SendDocumentWithContext(ctx context.Context, params UploadDocumentP, files ...UploaderFile) (Message, error) {
+func (u *Uploader) SendDocumentWithContext(ctx context.Context, params UploadDocument, files ...UploaderFile) (Message, error) {
 	req := NewUploaderRequestWithChatID[Message]("sendDocument", params, params.ChatID, files...)
 	return req.DoWithContext(ctx, u)
 }
 
-// UploadVideoP holds parameters for uploading a video using the Uploader.
+// UploadVideo holds parameters for uploading a video using the Uploader.
 // See https://core.telegram.org/bots/api#sendvideo
-type UploadVideoP struct {
+type UploadVideo struct {
 	BusinessConnectionID  string `json:"business_connection_id,omitempty"`
 	ChatID                int64  `json:"chat_id"`
 	MessageThreadID       int    `json:"message_thread_id,omitempty"`
@@ -162,7 +162,7 @@ type UploadVideoP struct {
 // SendVideo uploads a video via multipart and sends it as a message.
 // files are the video file(s) to upload (typically one file).
 // See https://core.telegram.org/bots/api#sendvideo
-func (u *Uploader) SendVideo(params UploadVideoP, files ...UploaderFile) (Message, error) {
+func (u *Uploader) SendVideo(params UploadVideo, files ...UploaderFile) (Message, error) {
 	req := NewUploaderRequestWithChatID[Message]("sendVideo", params, params.ChatID, files...)
 	return req.Do(u)
 }
@@ -172,14 +172,14 @@ func (u *Uploader) SendVideo(params UploadVideoP, files ...UploaderFile) (Messag
 // SendVideoWithContext is the context-aware variant of SendVideo.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#sendvideo
-func (u *Uploader) SendVideoWithContext(ctx context.Context, params UploadVideoP, files ...UploaderFile) (Message, error) {
+func (u *Uploader) SendVideoWithContext(ctx context.Context, params UploadVideo, files ...UploaderFile) (Message, error) {
 	req := NewUploaderRequestWithChatID[Message]("sendVideo", params, params.ChatID, files...)
 	return req.DoWithContext(ctx, u)
 }
 
-// UploadAnimationP holds parameters for uploading an animation using the Uploader.
+// UploadAnimation holds parameters for uploading an animation using the Uploader.
 // See https://core.telegram.org/bots/api#sendanimation
-type UploadAnimationP struct {
+type UploadAnimation struct {
 	BusinessConnectionID  string `json:"business_connection_id,omitempty"`
 	ChatID                int64  `json:"chat_id"`
 	MessageThreadID       int    `json:"message_thread_id,omitempty"`
@@ -208,7 +208,7 @@ type UploadAnimationP struct {
 // SendAnimation uploads an animation via multipart and sends it as a message.
 // files are the animation file(s) to upload (typically one file).
 // See https://core.telegram.org/bots/api#sendanimation
-func (u *Uploader) SendAnimation(params UploadAnimationP, files ...UploaderFile) (Message, error) {
+func (u *Uploader) SendAnimation(params UploadAnimation, files ...UploaderFile) (Message, error) {
 	req := NewUploaderRequestWithChatID[Message]("sendAnimation", params, params.ChatID, files...)
 	return req.Do(u)
 }
@@ -218,14 +218,14 @@ func (u *Uploader) SendAnimation(params UploadAnimationP, files ...UploaderFile)
 // SendAnimationWithContext is the context-aware variant of SendAnimation.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#sendanimation
-func (u *Uploader) SendAnimationWithContext(ctx context.Context, params UploadAnimationP, files ...UploaderFile) (Message, error) {
+func (u *Uploader) SendAnimationWithContext(ctx context.Context, params UploadAnimation, files ...UploaderFile) (Message, error) {
 	req := NewUploaderRequestWithChatID[Message]("sendAnimation", params, params.ChatID, files...)
 	return req.DoWithContext(ctx, u)
 }
 
-// UploadVoiceP holds parameters for uploading a voice note using the Uploader.
+// UploadVoice holds parameters for uploading a voice note using the Uploader.
 // See https://core.telegram.org/bots/api#sendvoice
-type UploadVoiceP struct {
+type UploadVoice struct {
 	BusinessConnectionID  string `json:"business_connection_id,omitempty"`
 	ChatID                int64  `json:"chat_id"`
 	MessageThreadID       int    `json:"message_thread_id,omitempty"`
@@ -249,7 +249,7 @@ type UploadVoiceP struct {
 // SendVoice uploads a voice note via multipart and sends it as a message.
 // files are the voice file(s) to upload (typically one file).
 // See https://core.telegram.org/bots/api#sendvoice
-func (u *Uploader) SendVoice(params UploadVoiceP, files ...UploaderFile) (Message, error) {
+func (u *Uploader) SendVoice(params UploadVoice, files ...UploaderFile) (Message, error) {
 	req := NewUploaderRequestWithChatID[Message]("sendVoice", params, params.ChatID, files...)
 	return req.Do(u)
 }
@@ -259,14 +259,14 @@ func (u *Uploader) SendVoice(params UploadVoiceP, files ...UploaderFile) (Messag
 // SendVoiceWithContext is the context-aware variant of SendVoice.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#sendvoice
-func (u *Uploader) SendVoiceWithContext(ctx context.Context, params UploadVoiceP, files ...UploaderFile) (Message, error) {
+func (u *Uploader) SendVoiceWithContext(ctx context.Context, params UploadVoice, files ...UploaderFile) (Message, error) {
 	req := NewUploaderRequestWithChatID[Message]("sendVoice", params, params.ChatID, files...)
 	return req.DoWithContext(ctx, u)
 }
 
-// UploadVideoNoteP holds parameters for uploading a video note (rounded video) using the Uploader.
+// UploadVideoNote holds parameters for uploading a video note (rounded video) using the Uploader.
 // See https://core.telegram.org/bots/api#sendvideonote
-type UploadVideoNoteP struct {
+type UploadVideoNote struct {
 	BusinessConnectionID  string `json:"business_connection_id,omitempty"`
 	ChatID                int64  `json:"chat_id"`
 	MessageThreadID       int    `json:"message_thread_id,omitempty"`
@@ -288,7 +288,7 @@ type UploadVideoNoteP struct {
 // SendVideoNote uploads a video note via multipart and sends it as a message.
 // files are the video note file(s) to upload (typically one file).
 // See https://core.telegram.org/bots/api#sendvideonote
-func (u *Uploader) SendVideoNote(params UploadVideoNoteP, files ...UploaderFile) (Message, error) {
+func (u *Uploader) SendVideoNote(params UploadVideoNote, files ...UploaderFile) (Message, error) {
 	req := NewUploaderRequestWithChatID[Message]("sendVideoNote", params, params.ChatID, files...)
 	return req.Do(u)
 }
@@ -298,21 +298,21 @@ func (u *Uploader) SendVideoNote(params UploadVideoNoteP, files ...UploaderFile)
 // SendVideoNoteWithContext is the context-aware variant of SendVideoNote.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#sendvideonote
-func (u *Uploader) SendVideoNoteWithContext(ctx context.Context, params UploadVideoNoteP, files ...UploaderFile) (Message, error) {
+func (u *Uploader) SendVideoNoteWithContext(ctx context.Context, params UploadVideoNote, files ...UploaderFile) (Message, error) {
 	req := NewUploaderRequestWithChatID[Message]("sendVideoNote", params, params.ChatID, files...)
 	return req.DoWithContext(ctx, u)
 }
 
-// UploadChatPhotoP holds parameters for uploading a chat photo using the Uploader.
+// UploadChatPhoto holds parameters for uploading a chat photo using the Uploader.
 // See https://core.telegram.org/bots/api#setchatphoto
-type UploadChatPhotoP struct {
+type UploadChatPhoto struct {
 	ChatID int64 `json:"chat_id"`
 }
 
 // SetChatPhoto uploads a new chat photo.
 // photo is the photo file to upload.
 // See https://core.telegram.org/bots/api#setchatphoto
-func (u *Uploader) SetChatPhoto(params UploadChatPhotoP, photo UploaderFile) (bool, error) {
+func (u *Uploader) SetChatPhoto(params UploadChatPhoto, photo UploaderFile) (bool, error) {
 	req := NewUploaderRequestWithChatID[bool]("setChatPhoto", params, params.ChatID, photo)
 	return req.Do(u)
 }
@@ -322,18 +322,18 @@ func (u *Uploader) SetChatPhoto(params UploadChatPhotoP, photo UploaderFile) (bo
 // SetChatPhotoWithContext is the context-aware variant of SetChatPhoto.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#setchatphoto
-func (u *Uploader) SetChatPhotoWithContext(ctx context.Context, params UploadChatPhotoP, photo UploaderFile) (bool, error) {
+func (u *Uploader) SetChatPhotoWithContext(ctx context.Context, params UploadChatPhoto, photo UploaderFile) (bool, error) {
 	req := NewUploaderRequestWithChatID[bool]("setChatPhoto", params, params.ChatID, photo)
 	return req.DoWithContext(ctx, u)
 }
 
-// UploadSetWebhookP holds multipart parameters for the setWebhook method.
+// UploadSetWebhook holds multipart parameters for the setWebhook method.
 // Use this type when uploading a self-signed certificate file.
 // See https://core.telegram.org/bots/api#setwebhook
-type UploadSetWebhookP struct {
+type UploadSetWebhook struct {
 	URL                string       `json:"url"`
 	IPAddress          string       `json:"ip_address,omitempty"`
-	MaxConnections     int          `json:"max_connections,omitempty"`
+	MaxConnections     int8         `json:"max_connections,omitempty"`
 	AllowedUpdates     []UpdateType `json:"allowed_updates,omitempty"`
 	DropPendingUpdates bool         `json:"drop_pending_updates,omitempty"`
 	SecretToken        string       `json:"secret_token,omitempty"`
@@ -342,7 +342,7 @@ type UploadSetWebhookP struct {
 // SetWebhook uploads a certificate and sets a webhook URL.
 // certificate maps to the multipart field \"certificate\".
 // See https://core.telegram.org/bots/api#setwebhook
-func (u *Uploader) SetWebhook(params UploadSetWebhookP, certificate UploaderFile) (bool, error) {
+func (u *Uploader) SetWebhook(params UploadSetWebhook, certificate UploaderFile) (bool, error) {
 	req := NewUploaderRequest[bool]("setWebhook", params, certificate.SetType(UploaderCertificateType))
 	return req.Do(u)
 }
@@ -350,7 +350,7 @@ func (u *Uploader) SetWebhook(params UploadSetWebhookP, certificate UploaderFile
 // SetWebhookWithContext is the context-aware variant of SetWebhook.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#setwebhook
-func (u *Uploader) SetWebhookWithContext(ctx context.Context, params UploadSetWebhookP, certificate UploaderFile) (bool, error) {
+func (u *Uploader) SetWebhookWithContext(ctx context.Context, params UploadSetWebhook, certificate UploaderFile) (bool, error) {
 	req := NewUploaderRequest[bool]("setWebhook", params, certificate.SetType(UploaderCertificateType))
 	return req.DoWithContext(ctx, u)
 }

tgapi/users_methods.go

@@ -2,9 +2,9 @@ package tgapi
 
 import "context"
 
-// GetUserProfilePhotosP holds parameters for the GetUserProfilePhotos method.
+// GetUserProfilePhotos holds parameters for the GetUserProfilePhotos method.
 // See https://core.telegram.org/bots/api#getuserprofilephotos
-type GetUserProfilePhotosP struct {
+type GetUserProfilePhotos struct {
 	UserID int64 `json:"user_id"`
 	Offset int   `json:"offset,omitempty"`
 	Limit  int   `json:"limit,omitempty"`
@@ -12,7 +12,7 @@ type GetUserProfilePhotosP struct {
 
 // GetUserProfilePhotos returns a list of profile pictures for a user.
 // See https://core.telegram.org/bots/api#getuserprofilephotos
-func (api *API) GetUserProfilePhotos(params GetUserProfilePhotosP) (UserProfilePhotos, error) {
+func (api *API) GetUserProfilePhotos(params GetUserProfilePhotos) (UserProfilePhotos, error) {
 	req := NewRequest[UserProfilePhotos]("getUserProfilePhotos", params)
 	return req.Do(api)
 }
@@ -20,14 +20,14 @@ func (api *API) GetUserProfilePhotos(params GetUserProfilePhotosP) (UserProfileP
 // GetUserProfilePhotosWithContext is the context-aware variant of GetUserProfilePhotos.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#getuserprofilephotos
-func (api *API) GetUserProfilePhotosWithContext(ctx context.Context, params GetUserProfilePhotosP) (UserProfilePhotos, error) {
+func (api *API) GetUserProfilePhotosWithContext(ctx context.Context, params GetUserProfilePhotos) (UserProfilePhotos, error) {
 	req := NewRequest[UserProfilePhotos]("getUserProfilePhotos", params)
 	return req.DoWithContext(ctx, api)
 }
 
-// GetUserProfileAudiosP holds parameters for the GetUserProfileAudios method.
+// GetUserProfileAudios holds parameters for the GetUserProfileAudios method.
 // See https://core.telegram.org/bots/api#getuserprofileaudios
-type GetUserProfileAudiosP struct {
+type GetUserProfileAudios struct {
 	UserID int64 `json:"user_id"`
 	Offset int   `json:"offset,omitempty"`
 	Limit  int   `json:"limit,omitempty"`
@@ -35,7 +35,7 @@ type GetUserProfileAudiosP struct {
 
 // GetUserProfileAudios returns a list of profile audios for a user.
 // See https://core.telegram.org/bots/api#getuserprofileaudios
-func (api *API) GetUserProfileAudios(params GetUserProfileAudiosP) (UserProfileAudios, error) {
+func (api *API) GetUserProfileAudios(params GetUserProfileAudios) (UserProfileAudios, error) {
 	req := NewRequest[UserProfileAudios]("getUserProfileAudios", params)
 	return req.Do(api)
 }
@@ -43,14 +43,14 @@ func (api *API) GetUserProfileAudios(params GetUserProfileAudiosP) (UserProfileA
 // GetUserProfileAudiosWithContext is the context-aware variant of GetUserProfileAudios.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#getuserprofileaudios
-func (api *API) GetUserProfileAudiosWithContext(ctx context.Context, params GetUserProfileAudiosP) (UserProfileAudios, error) {
+func (api *API) GetUserProfileAudiosWithContext(ctx context.Context, params GetUserProfileAudios) (UserProfileAudios, error) {
 	req := NewRequest[UserProfileAudios]("getUserProfileAudios", params)
 	return req.DoWithContext(ctx, api)
 }
 
-// SetUserEmojiStatusP holds parameters for the SetUserEmojiStatus method.
+// SetUserEmojiStatus holds parameters for the SetUserEmojiStatus method.
 // See https://core.telegram.org/bots/api#setuseremojistatus
-type SetUserEmojiStatusP struct {
+type SetUserEmojiStatus struct {
 	UserID         int64  `json:"user_id"`
 	EmojiID        string `json:"emoji_status_custom_emoji_id,omitempty"`
 	ExpirationDate int    `json:"emoji_status_expiration_date,omitempty"`
@@ -59,7 +59,7 @@ type SetUserEmojiStatusP struct {
 // SetUserEmojiStatus sets a custom emoji status for a user.
 // Returns true on success.
 // See https://core.telegram.org/bots/api#setuseremojistatus
-func (api *API) SetUserEmojiStatus(params SetUserEmojiStatusP) (bool, error) {
+func (api *API) SetUserEmojiStatus(params SetUserEmojiStatus) (bool, error) {
 	req := NewRequest[bool]("setUserEmojiStatus", params)
 	return req.Do(api)
 }
@@ -67,14 +67,14 @@ func (api *API) SetUserEmojiStatus(params SetUserEmojiStatusP) (bool, error) {
 // SetUserEmojiStatusWithContext is the context-aware variant of SetUserEmojiStatus.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#setuseremojistatus
-func (api *API) SetUserEmojiStatusWithContext(ctx context.Context, params SetUserEmojiStatusP) (bool, error) {
+func (api *API) SetUserEmojiStatusWithContext(ctx context.Context, params SetUserEmojiStatus) (bool, error) {
 	req := NewRequest[bool]("setUserEmojiStatus", params)
 	return req.DoWithContext(ctx, api)
 }
 
-// GetUserGiftsP holds parameters for the GetUserGifts method.
+// GetUserGifts holds parameters for the GetUserGifts method.
 // See https://core.telegram.org/bots/api#getusergifts
-type GetUserGiftsP struct {
+type GetUserGifts struct {
 	UserID                      int64  `json:"user_id"`
 	ExcludeUnlimited            bool   `json:"exclude_unlimited,omitempty"`
 	ExcludeLimitedUpgradable    bool   `json:"exclude_limited_upgradable,omitempty"`
@@ -88,7 +88,7 @@ type GetUserGiftsP struct {
 
 // GetUserGifts returns gifts owned by a user.
 // See https://core.telegram.org/bots/api#getusergifts
-func (api *API) GetUserGifts(params GetUserGiftsP) (OwnedGifts, error) {
+func (api *API) GetUserGifts(params GetUserGifts) (OwnedGifts, error) {
 	req := NewRequest[OwnedGifts]("getUserGifts", params)
 	return req.Do(api)
 }
@@ -96,7 +96,7 @@ func (api *API) GetUserGifts(params GetUserGiftsP) (OwnedGifts, error) {
 // GetUserGiftsWithContext is the context-aware variant of GetUserGifts.
 // It executes the same request but uses ctx for cancellation and deadlines.
 // See https://core.telegram.org/bots/api#getusergifts
-func (api *API) GetUserGiftsWithContext(ctx context.Context, params GetUserGiftsP) (OwnedGifts, error) {
+func (api *API) GetUserGiftsWithContext(ctx context.Context, params GetUserGifts) (OwnedGifts, error) {
 	req := NewRequest[OwnedGifts]("getUserGifts", params)
 	return req.DoWithContext(ctx, api)
 }

tgapi/users_types.go

@@ -13,6 +13,7 @@ type User struct {
 	AddedToAttachmentMenu     *bool   `json:"added_to_attachment_menu,omitempty"`
 	CanJoinGroups             *bool   `json:"can_join_groups,omitempty"`
 	CanReadAllGroupMessages   *bool   `json:"can_read_all_group_messages,omitempty"`
+	CanManageBots             *bool   `json:"can_manage_bots,omitempty"`
 	SupportsInlineQueries     *bool   `json:"supports_inline_queries,omitempty"`
 	CanConnectToBusiness      *bool   `json:"can_connect_to_business,omitempty"`
 	HasMainWebApp             *bool   `json:"has_main_web_app,omitempty"`

utils/multipart_test.go

@@ -19,10 +19,9 @@ type multipartEncodeParams struct {
 }
 
 func TestEncodeMultipartJSONFields(t *testing.T) {
-	threadID := 7
 	params := multipartEncodeParams{
 		ChatID:          42,
-		MessageThreadID: &threadID,
+		MessageThreadID: new(7),
 		ReplyMarkup: &tgapi.ReplyMarkup{
 			InlineKeyboard: [][]tgapi.InlineKeyboardButton{{
 				{Text: "A", CallbackData: "b"},

utils/version.go

@@ -2,7 +2,7 @@ package utils
 
 const (
 	// VersionString is the module version string.
-	VersionString = "1.0.0-rc.13"
+	VersionString = "1.0.0-rc.14"
 	// VersionMajor is the module major version.
 	VersionMajor = 1
 	// VersionMinor is the module minor version.
@@ -10,5 +10,5 @@ const (
 	// VersionPatch is the module patch version.
 	VersionPatch = 0
 	// VersionBeta is the prerelease counter for the current version.
-	VersionBeta = 13
+	VersionBeta = 14
 )