README

Golang bindings for the Telegram Bot API

GoDoc Travis

All methods are fairly self explanatory, and reading the godoc page should explain everything. If something isn't clear, open an issue or submit a pull request.

The scope of this project is just to provide a wrapper around the API without any additional features. There are other projects for creating something with plugins and command handlers without having to design all that yourself.

Join the development group if you want to ask questions or discuss development.

Example

First, ensure the library is installed and up to date by running go get -u github.com/go-telegram-bot-api/telegram-bot-api.

This is a very simple bot that just displays any gotten updates, then replies it to that chat.

package main

import (
	"log"

	"github.com/go-telegram-bot-api/telegram-bot-api"
)

func main() {
	bot, err := tgbotapi.NewBotAPI("MyAwesomeBotToken")
	if err != nil {
		log.Panic(err)
	}

	bot.Debug = true

	log.Printf("Authorized on account %s", bot.Self.UserName)

	u := tgbotapi.NewUpdate(0)
	u.Timeout = 60

	updates, err := bot.GetUpdatesChan(u)

	for update := range updates {
		if update.Message == nil { // ignore any non-Message Updates
			continue
		}

		log.Printf("[%s] %s", update.Message.From.UserName, update.Message.Text)

		msg := tgbotapi.NewMessage(update.Message.Chat.ID, update.Message.Text)
		msg.ReplyToMessageID = update.Message.MessageID

		bot.Send(msg)
	}
}

There are more examples on the wiki with detailed information on how to do many differen kinds of things. It's a great place to get started on using keyboards, commands, or other kinds of reply markup.

If you need to use webhooks (if you wish to run on Google App Engine), you may use a slightly different method.

package main

import (
	"log"
	"net/http"

	"github.com/go-telegram-bot-api/telegram-bot-api"
)

func main() {
	bot, err := tgbotapi.NewBotAPI("MyAwesomeBotToken")
	if err != nil {
		log.Fatal(err)
	}

	bot.Debug = true

	log.Printf("Authorized on account %s", bot.Self.UserName)

	_, err = bot.SetWebhook(tgbotapi.NewWebhookWithCert("https://www.google.com:8443/"+bot.Token, "cert.pem"))
	if err != nil {
		log.Fatal(err)
	}
	info, err := bot.GetWebhookInfo()
	if err != nil {
		log.Fatal(err)
	}
	if info.LastErrorDate != 0 {
		log.Printf("Telegram callback failed: %s", info.LastErrorMessage)
	}
	updates := bot.ListenForWebhook("/" + bot.Token)
	go http.ListenAndServeTLS("0.0.0.0:8443", "cert.pem", "key.pem", nil)

	for update := range updates {
		log.Printf("%+v\n", update)
	}
}

If you need, you may generate a self signed certficate, as this requires HTTPS / TLS. The above example tells Telegram that this is your certificate and that it should be trusted, even though it is not properly signed.

openssl req -x509 -newkey rsa:2048 -keyout key.pem -out cert.pem -days 3560 -subj "//O=Org\CN=Test" -nodes

Now that Let's Encrypt is available, you may wish to generate your free TLS certificate there.

Expand ▾ Collapse ▴

Documentation

Overview

    Package tgbotapi has functions and types used for interacting with the Telegram Bot API.

    Index

    Examples

    Constants

    View Source
    const (
    	// APIEndpoint is the endpoint for all API methods,
    	// with formatting for Sprintf.
    	APIEndpoint = "https://api.telegram.org/bot%s/%s"
    	// FileEndpoint is the endpoint for downloading a file from Telegram.
    	FileEndpoint = "https://api.telegram.org/file/bot%s/%s"
    )

      Telegram constants

      View Source
      const (
      	ChatTyping         = "typing"
      	ChatUploadPhoto    = "upload_photo"
      	ChatRecordVideo    = "record_video"
      	ChatUploadVideo    = "upload_video"
      	ChatRecordAudio    = "record_audio"
      	ChatUploadAudio    = "upload_audio"
      	ChatUploadDocument = "upload_document"
      	ChatFindLocation   = "find_location"
      )

        Constant values for ChatActions

        View Source
        const (
        	ModeMarkdown = "Markdown"
        	ModeHTML     = "HTML"
        )

          Constant values for ParseMode in MessageConfig

          View Source
          const (
          	// ErrBadFileType happens when you pass an unknown type
          	ErrBadFileType = "bad file type"
          	ErrBadURL      = "bad or empty url"
          )

            Library errors

            View Source
            const (
            	// ErrAPIForbidden happens when a token is bad
            	ErrAPIForbidden = "forbidden"
            )

              API errors

              Variables

              This section is empty.

              Functions

              func SetLogger

              func SetLogger(logger BotLogger) error

                SetLogger specifies the logger that the package should use.

                Types

                type APIResponse

                type APIResponse struct {
                	Ok          bool                `json:"ok"`
                	Result      json.RawMessage     `json:"result"`
                	ErrorCode   int                 `json:"error_code"`
                	Description string              `json:"description"`
                	Parameters  *ResponseParameters `json:"parameters"`
                }

                  APIResponse is a response from the Telegram API with the result stored raw.

                  type Animation

                  type Animation struct {
                  	FileID   string    `json:"file_id"`
                  	Thumb    PhotoSize `json:"thumb"`
                  	FileName string    `json:"file_name"`
                  	MimeType string    `json:"mime_type"`
                  	FileSize int       `json:"file_size"`
                  }

                    Animation is a GIF animation demonstrating the game.

                    type AnimationConfig

                    type AnimationConfig struct {
                    	BaseFile
                    	Duration  int
                    	Caption   string
                    	ParseMode string
                    }

                      AnimationConfig contains information about a SendAnimation request.

                      func NewAnimationShare

                      func NewAnimationShare(chatID int64, fileID string) AnimationConfig

                        NewAnimationShare shares an existing animation. You may use this to reshare an existing animation without reuploading it.

                        chatID is where to send it, fileID is the ID of the animation already uploaded.

                        func NewAnimationUpload

                        func NewAnimationUpload(chatID int64, file interface{}) AnimationConfig

                          NewAnimationUpload creates a new animation uploader.

                          chatID is where to send it, file is a string path to the file, FileReader, or FileBytes.

                          type Audio

                          type Audio struct {
                          	FileID    string `json:"file_id"`
                          	Duration  int    `json:"duration"`
                          	Performer string `json:"performer"` // optional
                          	Title     string `json:"title"`     // optional
                          	MimeType  string `json:"mime_type"` // optional
                          	FileSize  int    `json:"file_size"` // optional
                          }

                            Audio contains information about audio.

                            type AudioConfig

                            type AudioConfig struct {
                            	BaseFile
                            	Caption   string
                            	ParseMode string
                            	Duration  int
                            	Performer string
                            	Title     string
                            }

                              AudioConfig contains information about a SendAudio request.

                              func NewAudioShare

                              func NewAudioShare(chatID int64, fileID string) AudioConfig

                                NewAudioShare shares an existing audio file. You may use this to reshare an existing audio file without reuploading it.

                                chatID is where to send it, fileID is the ID of the audio already uploaded.

                                func NewAudioUpload

                                func NewAudioUpload(chatID int64, file interface{}) AudioConfig

                                  NewAudioUpload creates a new audio uploader.

                                  chatID is where to send it, file is a string path to the file, FileReader, or FileBytes.

                                  type BaseChat

                                  type BaseChat struct {
                                  	ChatID              int64 // required
                                  	ChannelUsername     string
                                  	ReplyToMessageID    int
                                  	ReplyMarkup         interface{}
                                  	DisableNotification bool
                                  }

                                    BaseChat is base type for all chat config types.

                                    type BaseEdit

                                    type BaseEdit struct {
                                    	ChatID          int64
                                    	ChannelUsername string
                                    	MessageID       int
                                    	InlineMessageID string
                                    	ReplyMarkup     *InlineKeyboardMarkup
                                    }

                                      BaseEdit is base type of all chat edits.

                                      type BaseFile

                                      type BaseFile struct {
                                      	BaseChat
                                      	File        interface{}
                                      	FileID      string
                                      	UseExisting bool
                                      	MimeType    string
                                      	FileSize    int
                                      }

                                        BaseFile is a base type for all file config types.

                                        type BotAPI

                                        type BotAPI struct {
                                        	Token  string `json:"token"`
                                        	Debug  bool   `json:"debug"`
                                        	Buffer int    `json:"buffer"`
                                        
                                        	Self   User         `json:"-"`
                                        	Client *http.Client `json:"-"`
                                        	// contains filtered or unexported fields
                                        }

                                          BotAPI allows you to interact with the Telegram Bot API.

                                          func NewBotAPI

                                          func NewBotAPI(token string) (*BotAPI, error)

                                            NewBotAPI creates a new BotAPI instance.

                                            It requires a token, provided by @BotFather on Telegram.

                                            Example
                                            Output:
                                            
                                            

                                            func NewBotAPIWithClient

                                            func NewBotAPIWithClient(token string, client *http.Client) (*BotAPI, error)

                                              NewBotAPIWithClient creates a new BotAPI instance and allows you to pass a http.Client.

                                              It requires a token, provided by @BotFather on Telegram.

                                              func (*BotAPI) AnswerCallbackQuery

                                              func (bot *BotAPI) AnswerCallbackQuery(config CallbackConfig) (APIResponse, error)

                                                AnswerCallbackQuery sends a response to an inline query callback.

                                                func (*BotAPI) AnswerInlineQuery

                                                func (bot *BotAPI) AnswerInlineQuery(config InlineConfig) (APIResponse, error)

                                                  AnswerInlineQuery sends a response to an inline query.

                                                  Note that you must respond to an inline query within 30 seconds.

                                                  func (*BotAPI) AnswerPreCheckoutQuery

                                                  func (bot *BotAPI) AnswerPreCheckoutQuery(config PreCheckoutConfig) (APIResponse, error)

                                                    AnswerPreCheckoutQuery allows you to reply to Update with pre_checkout_query.

                                                    func (*BotAPI) AnswerShippingQuery

                                                    func (bot *BotAPI) AnswerShippingQuery(config ShippingConfig) (APIResponse, error)

                                                      AnswerShippingQuery allows you to reply to Update with shipping_query parameter.

                                                      func (*BotAPI) DeleteChatPhoto

                                                      func (bot *BotAPI) DeleteChatPhoto(config DeleteChatPhotoConfig) (APIResponse, error)

                                                        DeleteChatPhoto delete photo of chat.

                                                        func (*BotAPI) DeleteMessage

                                                        func (bot *BotAPI) DeleteMessage(config DeleteMessageConfig) (APIResponse, error)

                                                          DeleteMessage deletes a message in a chat

                                                          func (*BotAPI) GetChat

                                                          func (bot *BotAPI) GetChat(config ChatConfig) (Chat, error)

                                                            GetChat gets information about a chat.

                                                            func (*BotAPI) GetChatAdministrators

                                                            func (bot *BotAPI) GetChatAdministrators(config ChatConfig) ([]ChatMember, error)

                                                              GetChatAdministrators gets a list of administrators in the chat.

                                                              If none have been appointed, only the creator will be returned. Bots are not shown, even if they are an administrator.

                                                              func (*BotAPI) GetChatMember

                                                              func (bot *BotAPI) GetChatMember(config ChatConfigWithUser) (ChatMember, error)

                                                                GetChatMember gets a specific chat member.

                                                                func (*BotAPI) GetChatMembersCount

                                                                func (bot *BotAPI) GetChatMembersCount(config ChatConfig) (int, error)

                                                                  GetChatMembersCount gets the number of users in a chat.

                                                                  func (*BotAPI) GetFile

                                                                  func (bot *BotAPI) GetFile(config FileConfig) (File, error)

                                                                    GetFile returns a File which can download a file from Telegram.

                                                                    Requires FileID.

                                                                    func (*BotAPI) GetFileDirectURL

                                                                    func (bot *BotAPI) GetFileDirectURL(fileID string) (string, error)

                                                                      GetFileDirectURL returns direct URL to file

                                                                      It requires the FileID.

                                                                      func (*BotAPI) GetGameHighScores

                                                                      func (bot *BotAPI) GetGameHighScores(config GetGameHighScoresConfig) ([]GameHighScore, error)

                                                                        GetGameHighScores allows you to get the high scores for a game.

                                                                        func (bot *BotAPI) GetInviteLink(config ChatConfig) (string, error)

                                                                          GetInviteLink get InviteLink for a chat

                                                                          func (*BotAPI) GetMe

                                                                          func (bot *BotAPI) GetMe() (User, error)

                                                                            GetMe fetches the currently authenticated bot.

                                                                            This method is called upon creation to validate the token, and so you may get this data from BotAPI.Self without the need for another request.

                                                                            func (*BotAPI) GetUpdates

                                                                            func (bot *BotAPI) GetUpdates(config UpdateConfig) ([]Update, error)

                                                                              GetUpdates fetches updates. If a WebHook is set, this will not return any data!

                                                                              Offset, Limit, and Timeout are optional. To avoid stale items, set Offset to one higher than the previous item. Set Timeout to a large number to reduce requests so you can get updates instantly instead of having to wait between requests.

                                                                              func (*BotAPI) GetUpdatesChan

                                                                              func (bot *BotAPI) GetUpdatesChan(config UpdateConfig) (UpdatesChannel, error)

                                                                                GetUpdatesChan starts and returns a channel for getting updates.

                                                                                func (*BotAPI) GetUserProfilePhotos

                                                                                func (bot *BotAPI) GetUserProfilePhotos(config UserProfilePhotosConfig) (UserProfilePhotos, error)

                                                                                  GetUserProfilePhotos gets a user's profile photos.

                                                                                  It requires UserID. Offset and Limit are optional.

                                                                                  func (*BotAPI) GetWebhookInfo

                                                                                  func (bot *BotAPI) GetWebhookInfo() (WebhookInfo, error)

                                                                                    GetWebhookInfo allows you to fetch information about a webhook and if one currently is set, along with pending update count and error messages.

                                                                                    func (*BotAPI) IsMessageToMe

                                                                                    func (bot *BotAPI) IsMessageToMe(message Message) bool

                                                                                      IsMessageToMe returns true if message directed to this bot.

                                                                                      It requires the Message.

                                                                                      func (*BotAPI) KickChatMember

                                                                                      func (bot *BotAPI) KickChatMember(config KickChatMemberConfig) (APIResponse, error)

                                                                                        KickChatMember kicks a user from a chat. Note that this only will work in supergroups, and requires the bot to be an admin. Also note they will be unable to rejoin until they are unbanned.

                                                                                        func (*BotAPI) LeaveChat

                                                                                        func (bot *BotAPI) LeaveChat(config ChatConfig) (APIResponse, error)

                                                                                          LeaveChat makes the bot leave the chat.

                                                                                          func (*BotAPI) ListenForWebhook

                                                                                          func (bot *BotAPI) ListenForWebhook(pattern string) UpdatesChannel

                                                                                            ListenForWebhook registers a http handler for a webhook.

                                                                                            func (*BotAPI) MakeRequest

                                                                                            func (bot *BotAPI) MakeRequest(endpoint string, params url.Values) (APIResponse, error)

                                                                                              MakeRequest makes a request to a specific endpoint with our token.

                                                                                              func (*BotAPI) PinChatMessage

                                                                                              func (bot *BotAPI) PinChatMessage(config PinChatMessageConfig) (APIResponse, error)

                                                                                                PinChatMessage pin message in supergroup

                                                                                                func (*BotAPI) PromoteChatMember

                                                                                                func (bot *BotAPI) PromoteChatMember(config PromoteChatMemberConfig) (APIResponse, error)

                                                                                                  PromoteChatMember add admin rights to user

                                                                                                  func (*BotAPI) RemoveWebhook

                                                                                                  func (bot *BotAPI) RemoveWebhook() (APIResponse, error)

                                                                                                    RemoveWebhook unsets the webhook.

                                                                                                    func (*BotAPI) RestrictChatMember

                                                                                                    func (bot *BotAPI) RestrictChatMember(config RestrictChatMemberConfig) (APIResponse, error)

                                                                                                      RestrictChatMember to restrict a user in a supergroup. The bot must be an administrator in the supergroup for this to work and must have the appropriate admin rights. Pass True for all boolean parameters to lift restrictions from a user. Returns True on success.

                                                                                                      func (*BotAPI) Send

                                                                                                      func (bot *BotAPI) Send(c Chattable) (Message, error)

                                                                                                        Send will send a Chattable item to Telegram.

                                                                                                        It requires the Chattable to send.

                                                                                                        func (*BotAPI) SetChatDescription

                                                                                                        func (bot *BotAPI) SetChatDescription(config SetChatDescriptionConfig) (APIResponse, error)

                                                                                                          SetChatDescription change description of chat.

                                                                                                          func (*BotAPI) SetChatPhoto

                                                                                                          func (bot *BotAPI) SetChatPhoto(config SetChatPhotoConfig) (APIResponse, error)

                                                                                                            SetChatPhoto change photo of chat.

                                                                                                            func (*BotAPI) SetChatTitle

                                                                                                            func (bot *BotAPI) SetChatTitle(config SetChatTitleConfig) (APIResponse, error)

                                                                                                              SetChatTitle change title of chat.

                                                                                                              func (*BotAPI) SetWebhook

                                                                                                              func (bot *BotAPI) SetWebhook(config WebhookConfig) (APIResponse, error)

                                                                                                                SetWebhook sets a webhook.

                                                                                                                If this is set, GetUpdates will not get any data!

                                                                                                                If you do not have a legitimate TLS certificate, you need to include your self signed certificate with the config.

                                                                                                                func (*BotAPI) StopReceivingUpdates

                                                                                                                func (bot *BotAPI) StopReceivingUpdates()

                                                                                                                  StopReceivingUpdates stops the go routine which receives updates

                                                                                                                  func (*BotAPI) UnbanChatMember

                                                                                                                  func (bot *BotAPI) UnbanChatMember(config ChatMemberConfig) (APIResponse, error)

                                                                                                                    UnbanChatMember unbans a user from a chat. Note that this only will work in supergroups and channels, and requires the bot to be an admin.

                                                                                                                    func (*BotAPI) UnpinChatMessage

                                                                                                                    func (bot *BotAPI) UnpinChatMessage(config UnpinChatMessageConfig) (APIResponse, error)

                                                                                                                      UnpinChatMessage unpin message in supergroup

                                                                                                                      func (*BotAPI) UploadFile

                                                                                                                      func (bot *BotAPI) UploadFile(endpoint string, params map[string]string, fieldname string, file interface{}) (APIResponse, error)

                                                                                                                        UploadFile makes a request to the API with a file.

                                                                                                                        Requires the parameter to hold the file not be in the params. File should be a string to a file path, a FileBytes struct, a FileReader struct, or a url.URL.

                                                                                                                        Note that if your FileReader has a size set to -1, it will read the file into memory to calculate a size.

                                                                                                                        type BotLogger

                                                                                                                        type BotLogger interface {
                                                                                                                        	Println(v ...interface{})
                                                                                                                        	Printf(format string, v ...interface{})
                                                                                                                        }

                                                                                                                          BotLogger is an interface that represents the required methods to log data.

                                                                                                                          Instead of requiring the standard logger, we can just specify the methods we use and allow users to pass anything that implements these.

                                                                                                                          type CallbackConfig

                                                                                                                          type CallbackConfig struct {
                                                                                                                          	CallbackQueryID string `json:"callback_query_id"`
                                                                                                                          	Text            string `json:"text"`
                                                                                                                          	ShowAlert       bool   `json:"show_alert"`
                                                                                                                          	URL             string `json:"url"`
                                                                                                                          	CacheTime       int    `json:"cache_time"`
                                                                                                                          }

                                                                                                                            CallbackConfig contains information on making a CallbackQuery response.

                                                                                                                            func NewCallback

                                                                                                                            func NewCallback(id, text string) CallbackConfig

                                                                                                                              NewCallback creates a new callback message.

                                                                                                                              func NewCallbackWithAlert

                                                                                                                              func NewCallbackWithAlert(id, text string) CallbackConfig

                                                                                                                                NewCallbackWithAlert creates a new callback message that alerts the user.

                                                                                                                                type CallbackGame

                                                                                                                                type CallbackGame struct{}

                                                                                                                                  CallbackGame is for starting a game in an inline keyboard button.

                                                                                                                                  type CallbackQuery

                                                                                                                                  type CallbackQuery struct {
                                                                                                                                  	ID              string   `json:"id"`
                                                                                                                                  	From            *User    `json:"from"`
                                                                                                                                  	Message         *Message `json:"message"`           // optional
                                                                                                                                  	InlineMessageID string   `json:"inline_message_id"` // optional
                                                                                                                                  	ChatInstance    string   `json:"chat_instance"`
                                                                                                                                  	Data            string   `json:"data"`            // optional
                                                                                                                                  	GameShortName   string   `json:"game_short_name"` // optional
                                                                                                                                  }

                                                                                                                                    CallbackQuery is data sent when a keyboard button with callback data is clicked.

                                                                                                                                    type Chat

                                                                                                                                    type Chat struct {
                                                                                                                                    	ID                  int64      `json:"id"`
                                                                                                                                    	Type                string     `json:"type"`
                                                                                                                                    	Title               string     `json:"title"`                          // optional
                                                                                                                                    	UserName            string     `json:"username"`                       // optional
                                                                                                                                    	FirstName           string     `json:"first_name"`                     // optional
                                                                                                                                    	LastName            string     `json:"last_name"`                      // optional
                                                                                                                                    	AllMembersAreAdmins bool       `json:"all_members_are_administrators"` // optional
                                                                                                                                    	Photo               *ChatPhoto `json:"photo"`
                                                                                                                                    	Description         string     `json:"description,omitempty"` // optional
                                                                                                                                    	InviteLink          string     `json:"invite_link,omitempty"` // optional
                                                                                                                                    }

                                                                                                                                      Chat contains information about the place a message was sent.

                                                                                                                                      func (Chat) ChatConfig

                                                                                                                                      func (c Chat) ChatConfig() ChatConfig

                                                                                                                                        ChatConfig returns a ChatConfig struct for chat related methods.

                                                                                                                                        func (Chat) IsChannel

                                                                                                                                        func (c Chat) IsChannel() bool

                                                                                                                                          IsChannel returns if the Chat is a channel.

                                                                                                                                          func (Chat) IsGroup

                                                                                                                                          func (c Chat) IsGroup() bool

                                                                                                                                            IsGroup returns if the Chat is a group.

                                                                                                                                            func (Chat) IsPrivate

                                                                                                                                            func (c Chat) IsPrivate() bool

                                                                                                                                              IsPrivate returns if the Chat is a private conversation.

                                                                                                                                              func (Chat) IsSuperGroup

                                                                                                                                              func (c Chat) IsSuperGroup() bool

                                                                                                                                                IsSuperGroup returns if the Chat is a supergroup.

                                                                                                                                                type ChatActionConfig

                                                                                                                                                type ChatActionConfig struct {
                                                                                                                                                	BaseChat
                                                                                                                                                	Action string // required
                                                                                                                                                }

                                                                                                                                                  ChatActionConfig contains information about a SendChatAction request.

                                                                                                                                                  func NewChatAction

                                                                                                                                                  func NewChatAction(chatID int64, action string) ChatActionConfig

                                                                                                                                                    NewChatAction sets a chat action. Actions last for 5 seconds, or until your next action.

                                                                                                                                                    chatID is where to send it, action should be set via Chat constants.

                                                                                                                                                    type ChatAnimation

                                                                                                                                                    type ChatAnimation struct {
                                                                                                                                                    	FileID    string     `json:"file_id"`
                                                                                                                                                    	Width     int        `json:"width"`
                                                                                                                                                    	Height    int        `json:"height"`
                                                                                                                                                    	Duration  int        `json:"duration"`
                                                                                                                                                    	Thumbnail *PhotoSize `json:"thumb"`     // optional
                                                                                                                                                    	FileName  string     `json:"file_name"` // optional
                                                                                                                                                    	MimeType  string     `json:"mime_type"` // optional
                                                                                                                                                    	FileSize  int        `json:"file_size"` // optional
                                                                                                                                                    }

                                                                                                                                                      ChatAnimation contains information about an animation.

                                                                                                                                                      type ChatConfig

                                                                                                                                                      type ChatConfig struct {
                                                                                                                                                      	ChatID             int64
                                                                                                                                                      	SuperGroupUsername string
                                                                                                                                                      }

                                                                                                                                                        ChatConfig contains information about getting information on a chat.

                                                                                                                                                        type ChatConfigWithUser

                                                                                                                                                        type ChatConfigWithUser struct {
                                                                                                                                                        	ChatID             int64
                                                                                                                                                        	SuperGroupUsername string
                                                                                                                                                        	UserID             int
                                                                                                                                                        }

                                                                                                                                                          ChatConfigWithUser contains information about getting information on a specific user within a chat.

                                                                                                                                                          type ChatMember

                                                                                                                                                          type ChatMember struct {
                                                                                                                                                          	User                  *User  `json:"user"`
                                                                                                                                                          	Status                string `json:"status"`
                                                                                                                                                          	UntilDate             int64  `json:"until_date,omitempty"`                // optional
                                                                                                                                                          	CanBeEdited           bool   `json:"can_be_edited,omitempty"`             // optional
                                                                                                                                                          	CanChangeInfo         bool   `json:"can_change_info,omitempty"`           // optional
                                                                                                                                                          	CanPostMessages       bool   `json:"can_post_messages,omitempty"`         // optional
                                                                                                                                                          	CanEditMessages       bool   `json:"can_edit_messages,omitempty"`         // optional
                                                                                                                                                          	CanDeleteMessages     bool   `json:"can_delete_messages,omitempty"`       // optional
                                                                                                                                                          	CanInviteUsers        bool   `json:"can_invite_users,omitempty"`          // optional
                                                                                                                                                          	CanRestrictMembers    bool   `json:"can_restrict_members,omitempty"`      // optional
                                                                                                                                                          	CanPinMessages        bool   `json:"can_pin_messages,omitempty"`          // optional
                                                                                                                                                          	CanPromoteMembers     bool   `json:"can_promote_members,omitempty"`       // optional
                                                                                                                                                          	CanSendMessages       bool   `json:"can_send_messages,omitempty"`         // optional
                                                                                                                                                          	CanSendMediaMessages  bool   `json:"can_send_media_messages,omitempty"`   // optional
                                                                                                                                                          	CanSendOtherMessages  bool   `json:"can_send_other_messages,omitempty"`   // optional
                                                                                                                                                          	CanAddWebPagePreviews bool   `json:"can_add_web_page_previews,omitempty"` // optional
                                                                                                                                                          }

                                                                                                                                                            ChatMember is information about a member in a chat.

                                                                                                                                                            func (ChatMember) HasLeft

                                                                                                                                                            func (chat ChatMember) HasLeft() bool

                                                                                                                                                              HasLeft returns if the ChatMember left the chat.

                                                                                                                                                              func (ChatMember) IsAdministrator

                                                                                                                                                              func (chat ChatMember) IsAdministrator() bool

                                                                                                                                                                IsAdministrator returns if the ChatMember is a chat administrator.

                                                                                                                                                                func (ChatMember) IsCreator

                                                                                                                                                                func (chat ChatMember) IsCreator() bool

                                                                                                                                                                  IsCreator returns if the ChatMember was the creator of the chat.

                                                                                                                                                                  func (ChatMember) IsMember

                                                                                                                                                                  func (chat ChatMember) IsMember() bool

                                                                                                                                                                    IsMember returns if the ChatMember is a current member of the chat.

                                                                                                                                                                    func (ChatMember) WasKicked

                                                                                                                                                                    func (chat ChatMember) WasKicked() bool

                                                                                                                                                                      WasKicked returns if the ChatMember was kicked from the chat.

                                                                                                                                                                      type ChatMemberConfig

                                                                                                                                                                      type ChatMemberConfig struct {
                                                                                                                                                                      	ChatID             int64
                                                                                                                                                                      	SuperGroupUsername string
                                                                                                                                                                      	ChannelUsername    string
                                                                                                                                                                      	UserID             int
                                                                                                                                                                      }

                                                                                                                                                                        ChatMemberConfig contains information about a user in a chat for use with administrative functions such as kicking or unbanning a user.

                                                                                                                                                                        type ChatPhoto

                                                                                                                                                                        type ChatPhoto struct {
                                                                                                                                                                        	SmallFileID string `json:"small_file_id"`
                                                                                                                                                                        	BigFileID   string `json:"big_file_id"`
                                                                                                                                                                        }

                                                                                                                                                                          ChatPhoto represents a chat photo.

                                                                                                                                                                          type Chattable

                                                                                                                                                                          type Chattable interface {
                                                                                                                                                                          	// contains filtered or unexported methods
                                                                                                                                                                          }

                                                                                                                                                                            Chattable is any config type that can be sent.

                                                                                                                                                                            type ChosenInlineResult

                                                                                                                                                                            type ChosenInlineResult struct {
                                                                                                                                                                            	ResultID        string    `json:"result_id"`
                                                                                                                                                                            	From            *User     `json:"from"`
                                                                                                                                                                            	Location        *Location `json:"location"`
                                                                                                                                                                            	InlineMessageID string    `json:"inline_message_id"`
                                                                                                                                                                            	Query           string    `json:"query"`
                                                                                                                                                                            }

                                                                                                                                                                              ChosenInlineResult is an inline query result chosen by a User

                                                                                                                                                                              type Contact

                                                                                                                                                                              type Contact struct {
                                                                                                                                                                              	PhoneNumber string `json:"phone_number"`
                                                                                                                                                                              	FirstName   string `json:"first_name"`
                                                                                                                                                                              	LastName    string `json:"last_name"` // optional
                                                                                                                                                                              	UserID      int    `json:"user_id"`   // optional
                                                                                                                                                                              }

                                                                                                                                                                                Contact contains information about a contact.

                                                                                                                                                                                Note that LastName and UserID may be empty.

                                                                                                                                                                                type ContactConfig

                                                                                                                                                                                type ContactConfig struct {
                                                                                                                                                                                	BaseChat
                                                                                                                                                                                	PhoneNumber string
                                                                                                                                                                                	FirstName   string
                                                                                                                                                                                	LastName    string
                                                                                                                                                                                }

                                                                                                                                                                                  ContactConfig allows you to send a contact.

                                                                                                                                                                                  func NewContact

                                                                                                                                                                                  func NewContact(chatID int64, phoneNumber, firstName string) ContactConfig

                                                                                                                                                                                    NewContact allows you to send a shared contact.

                                                                                                                                                                                    type Credentials

                                                                                                                                                                                    type Credentials struct {
                                                                                                                                                                                    	Data SecureData `json:"secure_data"`
                                                                                                                                                                                    	// Nonce the same nonce given in the request
                                                                                                                                                                                    	Nonce string `json:"nonce"`
                                                                                                                                                                                    }

                                                                                                                                                                                      Credentials contains encrypted data.

                                                                                                                                                                                      type DataCredentials

                                                                                                                                                                                      type DataCredentials struct {
                                                                                                                                                                                      	// DataHash checksum of encrypted data
                                                                                                                                                                                      	DataHash string `json:"data_hash"`
                                                                                                                                                                                      	// Secret of encrypted data
                                                                                                                                                                                      	Secret string `json:"secret"`
                                                                                                                                                                                      }

                                                                                                                                                                                        DataCredentials contains information required to decrypt data.

                                                                                                                                                                                        type DeleteChatPhotoConfig

                                                                                                                                                                                        type DeleteChatPhotoConfig struct {
                                                                                                                                                                                        	ChatID int64
                                                                                                                                                                                        }

                                                                                                                                                                                          DeleteChatPhotoConfig contains information for delete chat photo.

                                                                                                                                                                                          type DeleteMessageConfig

                                                                                                                                                                                          type DeleteMessageConfig struct {
                                                                                                                                                                                          	ChatID    int64
                                                                                                                                                                                          	MessageID int
                                                                                                                                                                                          }

                                                                                                                                                                                            DeleteMessageConfig contains information of a message in a chat to delete.

                                                                                                                                                                                            func NewDeleteMessage

                                                                                                                                                                                            func NewDeleteMessage(chatID int64, messageID int) DeleteMessageConfig

                                                                                                                                                                                              NewDeleteMessage creates a request to delete a message.

                                                                                                                                                                                              type Document

                                                                                                                                                                                              type Document struct {
                                                                                                                                                                                              	FileID    string     `json:"file_id"`
                                                                                                                                                                                              	Thumbnail *PhotoSize `json:"thumb"`     // optional
                                                                                                                                                                                              	FileName  string     `json:"file_name"` // optional
                                                                                                                                                                                              	MimeType  string     `json:"mime_type"` // optional
                                                                                                                                                                                              	FileSize  int        `json:"file_size"` // optional
                                                                                                                                                                                              }

                                                                                                                                                                                                Document contains information about a document.

                                                                                                                                                                                                type DocumentConfig

                                                                                                                                                                                                type DocumentConfig struct {
                                                                                                                                                                                                	BaseFile
                                                                                                                                                                                                	Caption   string
                                                                                                                                                                                                	ParseMode string
                                                                                                                                                                                                }

                                                                                                                                                                                                  DocumentConfig contains information about a SendDocument request.

                                                                                                                                                                                                  func NewDocumentShare

                                                                                                                                                                                                  func NewDocumentShare(chatID int64, fileID string) DocumentConfig

                                                                                                                                                                                                    NewDocumentShare shares an existing document. You may use this to reshare an existing document without reuploading it.

                                                                                                                                                                                                    chatID is where to send it, fileID is the ID of the document already uploaded.

                                                                                                                                                                                                    func NewDocumentUpload

                                                                                                                                                                                                    func NewDocumentUpload(chatID int64, file interface{}) DocumentConfig

                                                                                                                                                                                                      NewDocumentUpload creates a new document uploader.

                                                                                                                                                                                                      chatID is where to send it, file is a string path to the file, FileReader, or FileBytes.

                                                                                                                                                                                                      type EditMessageCaptionConfig

                                                                                                                                                                                                      type EditMessageCaptionConfig struct {
                                                                                                                                                                                                      	BaseEdit
                                                                                                                                                                                                      	Caption   string
                                                                                                                                                                                                      	ParseMode string
                                                                                                                                                                                                      }

                                                                                                                                                                                                        EditMessageCaptionConfig allows you to modify the caption of a message.

                                                                                                                                                                                                        func NewEditMessageCaption

                                                                                                                                                                                                        func NewEditMessageCaption(chatID int64, messageID int, caption string) EditMessageCaptionConfig

                                                                                                                                                                                                          NewEditMessageCaption allows you to edit the caption of a message.

                                                                                                                                                                                                          type EditMessageReplyMarkupConfig

                                                                                                                                                                                                          type EditMessageReplyMarkupConfig struct {
                                                                                                                                                                                                          	BaseEdit
                                                                                                                                                                                                          }

                                                                                                                                                                                                            EditMessageReplyMarkupConfig allows you to modify the reply markup of a message.

                                                                                                                                                                                                            func NewEditMessageReplyMarkup

                                                                                                                                                                                                            func NewEditMessageReplyMarkup(chatID int64, messageID int, replyMarkup InlineKeyboardMarkup) EditMessageReplyMarkupConfig

                                                                                                                                                                                                              NewEditMessageReplyMarkup allows you to edit the inline keyboard markup.

                                                                                                                                                                                                              type EditMessageTextConfig

                                                                                                                                                                                                              type EditMessageTextConfig struct {
                                                                                                                                                                                                              	BaseEdit
                                                                                                                                                                                                              	Text                  string
                                                                                                                                                                                                              	ParseMode             string
                                                                                                                                                                                                              	DisableWebPagePreview bool
                                                                                                                                                                                                              }

                                                                                                                                                                                                                EditMessageTextConfig allows you to modify the text in a message.

                                                                                                                                                                                                                func NewEditMessageText

                                                                                                                                                                                                                func NewEditMessageText(chatID int64, messageID int, text string) EditMessageTextConfig

                                                                                                                                                                                                                  NewEditMessageText allows you to edit the text of a message.

                                                                                                                                                                                                                  type EncryptedCredentials

                                                                                                                                                                                                                  type EncryptedCredentials struct {
                                                                                                                                                                                                                  	// Base64-encoded encrypted JSON-serialized data with unique user's
                                                                                                                                                                                                                  	// payload, data hashes and secrets required for EncryptedPassportElement
                                                                                                                                                                                                                  	// decryption and authentication
                                                                                                                                                                                                                  	Data string `json:"data"`
                                                                                                                                                                                                                  
                                                                                                                                                                                                                  	// Base64-encoded data hash for data authentication
                                                                                                                                                                                                                  	Hash string `json:"hash"`
                                                                                                                                                                                                                  
                                                                                                                                                                                                                  	// Base64-encoded secret, encrypted with the bot's public RSA key,
                                                                                                                                                                                                                  	// required for data decryption
                                                                                                                                                                                                                  	Secret string `json:"secret"`
                                                                                                                                                                                                                  }

                                                                                                                                                                                                                    EncryptedCredentials contains data required for decrypting and authenticating EncryptedPassportElement. See the Telegram Passport Documentation for a complete description of the data decryption and authentication processes.

                                                                                                                                                                                                                    type EncryptedPassportElement

                                                                                                                                                                                                                    type EncryptedPassportElement struct {
                                                                                                                                                                                                                    	// Element type.
                                                                                                                                                                                                                    	Type string `json:"type"`
                                                                                                                                                                                                                    
                                                                                                                                                                                                                    	// Base64-encoded encrypted Telegram Passport element data provided by
                                                                                                                                                                                                                    	// the user, available for "personal_details", "passport",
                                                                                                                                                                                                                    	// "driver_license", "identity_card", "identity_passport" and "address"
                                                                                                                                                                                                                    	// types. Can be decrypted and verified using the accompanying
                                                                                                                                                                                                                    	// EncryptedCredentials.
                                                                                                                                                                                                                    	Data string `json:"data,omitempty"`
                                                                                                                                                                                                                    
                                                                                                                                                                                                                    	// User's verified phone number, available only for "phone_number" type
                                                                                                                                                                                                                    	PhoneNumber string `json:"phone_number,omitempty"`
                                                                                                                                                                                                                    
                                                                                                                                                                                                                    	// User's verified email address, available only for "email" type
                                                                                                                                                                                                                    	Email string `json:"email,omitempty"`
                                                                                                                                                                                                                    
                                                                                                                                                                                                                    	// Array of encrypted files with documents provided by the user,
                                                                                                                                                                                                                    	// available for "utility_bill", "bank_statement", "rental_agreement",
                                                                                                                                                                                                                    	// "passport_registration" and "temporary_registration" types. Files can
                                                                                                                                                                                                                    	// be decrypted and verified using the accompanying EncryptedCredentials.
                                                                                                                                                                                                                    	Files []PassportFile `json:"files,omitempty"`
                                                                                                                                                                                                                    
                                                                                                                                                                                                                    	// Encrypted file with the front side of the document, provided by the
                                                                                                                                                                                                                    	// user. Available for "passport", "driver_license", "identity_card" and
                                                                                                                                                                                                                    	// "internal_passport". The file can be decrypted and verified using the
                                                                                                                                                                                                                    	// accompanying EncryptedCredentials.
                                                                                                                                                                                                                    	FrontSide *PassportFile `json:"front_side,omitempty"`
                                                                                                                                                                                                                    
                                                                                                                                                                                                                    	// Encrypted file with the reverse side of the document, provided by the
                                                                                                                                                                                                                    	// user. Available for "driver_license" and "identity_card". The file can
                                                                                                                                                                                                                    	// be decrypted and verified using the accompanying EncryptedCredentials.
                                                                                                                                                                                                                    	ReverseSide *PassportFile `json:"reverse_side,omitempty"`
                                                                                                                                                                                                                    
                                                                                                                                                                                                                    	// Encrypted file with the selfie of the user holding a document,
                                                                                                                                                                                                                    	// provided by the user; available for "passport", "driver_license",
                                                                                                                                                                                                                    	// "identity_card" and "internal_passport". The file can be decrypted
                                                                                                                                                                                                                    	// and verified using the accompanying EncryptedCredentials.
                                                                                                                                                                                                                    	Selfie *PassportFile `json:"selfie,omitempty"`
                                                                                                                                                                                                                    }

                                                                                                                                                                                                                      EncryptedPassportElement contains information about documents or other Telegram Passport elements shared with the bot by the user.

                                                                                                                                                                                                                      type Error

                                                                                                                                                                                                                      type Error struct {
                                                                                                                                                                                                                      	Message string
                                                                                                                                                                                                                      	ResponseParameters
                                                                                                                                                                                                                      }

                                                                                                                                                                                                                        Error is an error containing extra information returned by the Telegram API.

                                                                                                                                                                                                                        func (Error) Error

                                                                                                                                                                                                                        func (e Error) Error() string

                                                                                                                                                                                                                        type File

                                                                                                                                                                                                                        type File struct {
                                                                                                                                                                                                                        	FileID   string `json:"file_id"`
                                                                                                                                                                                                                        	FileSize int    `json:"file_size"` // optional
                                                                                                                                                                                                                        	FilePath string `json:"file_path"` // optional
                                                                                                                                                                                                                        }

                                                                                                                                                                                                                          File contains information about a file to download from Telegram.

                                                                                                                                                                                                                          func (f *File) Link(token string) string

                                                                                                                                                                                                                            Link returns a full path to the download URL for a File.

                                                                                                                                                                                                                            It requires the Bot Token to create the link.

                                                                                                                                                                                                                            type FileBytes

                                                                                                                                                                                                                            type FileBytes struct {
                                                                                                                                                                                                                            	Name  string
                                                                                                                                                                                                                            	Bytes []byte
                                                                                                                                                                                                                            }

                                                                                                                                                                                                                              FileBytes contains information about a set of bytes to upload as a File.

                                                                                                                                                                                                                              type FileConfig

                                                                                                                                                                                                                              type FileConfig struct {
                                                                                                                                                                                                                              	FileID string
                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                FileConfig has information about a file hosted on Telegram.

                                                                                                                                                                                                                                type FileCredentials

                                                                                                                                                                                                                                type FileCredentials struct {
                                                                                                                                                                                                                                	// FileHash checksum of encrypted data
                                                                                                                                                                                                                                	FileHash string `json:"file_hash"`
                                                                                                                                                                                                                                	// Secret of encrypted data
                                                                                                                                                                                                                                	Secret string `json:"secret"`
                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                  FileCredentials contains information required to decrypt files.

                                                                                                                                                                                                                                  type FileReader

                                                                                                                                                                                                                                  type FileReader struct {
                                                                                                                                                                                                                                  	Name   string
                                                                                                                                                                                                                                  	Reader io.Reader
                                                                                                                                                                                                                                  	Size   int64
                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                    FileReader contains information about a reader to upload as a File. If Size is -1, it will read the entire Reader into memory to calculate a Size.

                                                                                                                                                                                                                                    type Fileable

                                                                                                                                                                                                                                    type Fileable interface {
                                                                                                                                                                                                                                    	Chattable
                                                                                                                                                                                                                                    	// contains filtered or unexported methods
                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                      Fileable is any config type that can be sent that includes a file.

                                                                                                                                                                                                                                      type ForceReply

                                                                                                                                                                                                                                      type ForceReply struct {
                                                                                                                                                                                                                                      	ForceReply bool `json:"force_reply"`
                                                                                                                                                                                                                                      	Selective  bool `json:"selective"` // optional
                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                        ForceReply allows the Bot to have users directly reply to it without additional interaction.

                                                                                                                                                                                                                                        type ForwardConfig

                                                                                                                                                                                                                                        type ForwardConfig struct {
                                                                                                                                                                                                                                        	BaseChat
                                                                                                                                                                                                                                        	FromChatID          int64 // required
                                                                                                                                                                                                                                        	FromChannelUsername string
                                                                                                                                                                                                                                        	MessageID           int // required
                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                          ForwardConfig contains information about a ForwardMessage request.

                                                                                                                                                                                                                                          func NewForward

                                                                                                                                                                                                                                          func NewForward(chatID int64, fromChatID int64, messageID int) ForwardConfig

                                                                                                                                                                                                                                            NewForward creates a new forward.

                                                                                                                                                                                                                                            chatID is where to send it, fromChatID is the source chat, and messageID is the ID of the original message.

                                                                                                                                                                                                                                            type Game

                                                                                                                                                                                                                                            type Game struct {
                                                                                                                                                                                                                                            	Title        string          `json:"title"`
                                                                                                                                                                                                                                            	Description  string          `json:"description"`
                                                                                                                                                                                                                                            	Photo        []PhotoSize     `json:"photo"`
                                                                                                                                                                                                                                            	Text         string          `json:"text"`
                                                                                                                                                                                                                                            	TextEntities []MessageEntity `json:"text_entities"`
                                                                                                                                                                                                                                            	Animation    Animation       `json:"animation"`
                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                              Game is a game within Telegram.

                                                                                                                                                                                                                                              type GameConfig

                                                                                                                                                                                                                                              type GameConfig struct {
                                                                                                                                                                                                                                              	BaseChat
                                                                                                                                                                                                                                              	GameShortName string
                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                GameConfig allows you to send a game.

                                                                                                                                                                                                                                                type GameHighScore

                                                                                                                                                                                                                                                type GameHighScore struct {
                                                                                                                                                                                                                                                	Position int  `json:"position"`
                                                                                                                                                                                                                                                	User     User `json:"user"`
                                                                                                                                                                                                                                                	Score    int  `json:"score"`
                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                  GameHighScore is a user's score and position on the leaderboard.

                                                                                                                                                                                                                                                  type GetGameHighScoresConfig

                                                                                                                                                                                                                                                  type GetGameHighScoresConfig struct {
                                                                                                                                                                                                                                                  	UserID          int
                                                                                                                                                                                                                                                  	ChatID          int
                                                                                                                                                                                                                                                  	ChannelUsername string
                                                                                                                                                                                                                                                  	MessageID       int
                                                                                                                                                                                                                                                  	InlineMessageID string
                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                    GetGameHighScoresConfig allows you to fetch the high scores for a game.

                                                                                                                                                                                                                                                    type GroupChat

                                                                                                                                                                                                                                                    type GroupChat struct {
                                                                                                                                                                                                                                                    	ID    int    `json:"id"`
                                                                                                                                                                                                                                                    	Title string `json:"title"`
                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                      GroupChat is a group chat.

                                                                                                                                                                                                                                                      type IDDocumentData

                                                                                                                                                                                                                                                      type IDDocumentData struct {
                                                                                                                                                                                                                                                      	DocumentNumber string `json:"document_no"`
                                                                                                                                                                                                                                                      	ExpiryDate     string `json:"expiry_date"`
                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                        IDDocumentData https://core.telegram.org/passport#iddocumentdata

                                                                                                                                                                                                                                                        type InlineConfig

                                                                                                                                                                                                                                                        type InlineConfig struct {
                                                                                                                                                                                                                                                        	InlineQueryID     string        `json:"inline_query_id"`
                                                                                                                                                                                                                                                        	Results           []interface{} `json:"results"`
                                                                                                                                                                                                                                                        	CacheTime         int           `json:"cache_time"`
                                                                                                                                                                                                                                                        	IsPersonal        bool          `json:"is_personal"`
                                                                                                                                                                                                                                                        	NextOffset        string        `json:"next_offset"`
                                                                                                                                                                                                                                                        	SwitchPMText      string        `json:"switch_pm_text"`
                                                                                                                                                                                                                                                        	SwitchPMParameter string        `json:"switch_pm_parameter"`
                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                          InlineConfig contains information on making an InlineQuery response.

                                                                                                                                                                                                                                                          type InlineKeyboardButton

                                                                                                                                                                                                                                                          type InlineKeyboardButton struct {
                                                                                                                                                                                                                                                          	Text                         string        `json:"text"`
                                                                                                                                                                                                                                                          	URL                          *string       `json:"url,omitempty"`                              // optional
                                                                                                                                                                                                                                                          	CallbackData                 *string       `json:"callback_data,omitempty"`                    // optional
                                                                                                                                                                                                                                                          	SwitchInlineQuery            *string       `json:"switch_inline_query,omitempty"`              // optional
                                                                                                                                                                                                                                                          	SwitchInlineQueryCurrentChat *string       `json:"switch_inline_query_current_chat,omitempty"` // optional
                                                                                                                                                                                                                                                          	CallbackGame                 *CallbackGame `json:"callback_game,omitempty"`                    // optional
                                                                                                                                                                                                                                                          	Pay                          bool          `json:"pay,omitempty"`                              // optional
                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                            InlineKeyboardButton is a button within a custom keyboard for inline query responses.

                                                                                                                                                                                                                                                            Note that some values are references as even an empty string will change behavior.

                                                                                                                                                                                                                                                            CallbackGame, if set, MUST be first button in first row.

                                                                                                                                                                                                                                                            func NewInlineKeyboardButtonData

                                                                                                                                                                                                                                                            func NewInlineKeyboardButtonData(text, data string) InlineKeyboardButton

                                                                                                                                                                                                                                                              NewInlineKeyboardButtonData creates an inline keyboard button with text and data for a callback.

                                                                                                                                                                                                                                                              func NewInlineKeyboardButtonSwitch

                                                                                                                                                                                                                                                              func NewInlineKeyboardButtonSwitch(text, sw string) InlineKeyboardButton

                                                                                                                                                                                                                                                                NewInlineKeyboardButtonSwitch creates an inline keyboard button with text which allows the user to switch to a chat or return to a chat.

                                                                                                                                                                                                                                                                func NewInlineKeyboardButtonURL

                                                                                                                                                                                                                                                                func NewInlineKeyboardButtonURL(text, url string) InlineKeyboardButton

                                                                                                                                                                                                                                                                  NewInlineKeyboardButtonURL creates an inline keyboard button with text which goes to a URL.

                                                                                                                                                                                                                                                                  func NewInlineKeyboardRow

                                                                                                                                                                                                                                                                  func NewInlineKeyboardRow(buttons ...InlineKeyboardButton) []InlineKeyboardButton

                                                                                                                                                                                                                                                                    NewInlineKeyboardRow creates an inline keyboard row with buttons.

                                                                                                                                                                                                                                                                    type InlineKeyboardMarkup

                                                                                                                                                                                                                                                                    type InlineKeyboardMarkup struct {
                                                                                                                                                                                                                                                                    	InlineKeyboard [][]InlineKeyboardButton `json:"inline_keyboard"`
                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                      InlineKeyboardMarkup is a custom keyboard presented for an inline bot.

                                                                                                                                                                                                                                                                      func NewInlineKeyboardMarkup

                                                                                                                                                                                                                                                                      func NewInlineKeyboardMarkup(rows ...[]InlineKeyboardButton) InlineKeyboardMarkup

                                                                                                                                                                                                                                                                        NewInlineKeyboardMarkup creates a new inline keyboard.

                                                                                                                                                                                                                                                                        type InlineQuery

                                                                                                                                                                                                                                                                        type InlineQuery struct {
                                                                                                                                                                                                                                                                        	ID       string    `json:"id"`
                                                                                                                                                                                                                                                                        	From     *User     `json:"from"`
                                                                                                                                                                                                                                                                        	Location *Location `json:"location"` // optional
                                                                                                                                                                                                                                                                        	Query    string    `json:"query"`
                                                                                                                                                                                                                                                                        	Offset   string    `json:"offset"`
                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                          InlineQuery is a Query from Telegram for an inline request.

                                                                                                                                                                                                                                                                          type InlineQueryResultArticle

                                                                                                                                                                                                                                                                          type InlineQueryResultArticle struct {
                                                                                                                                                                                                                                                                          	Type                string                `json:"type"`                            // required
                                                                                                                                                                                                                                                                          	ID                  string                `json:"id"`                              // required
                                                                                                                                                                                                                                                                          	Title               string                `json:"title"`                           // required
                                                                                                                                                                                                                                                                          	InputMessageContent interface{}           `json:"input_message_content,omitempty"` // required
                                                                                                                                                                                                                                                                          	ReplyMarkup         *InlineKeyboardMarkup `json:"reply_markup,omitempty"`
                                                                                                                                                                                                                                                                          	URL                 string                `json:"url"`
                                                                                                                                                                                                                                                                          	HideURL             bool                  `json:"hide_url"`
                                                                                                                                                                                                                                                                          	Description         string                `json:"description"`
                                                                                                                                                                                                                                                                          	ThumbURL            string                `json:"thumb_url"`
                                                                                                                                                                                                                                                                          	ThumbWidth          int                   `json:"thumb_width"`
                                                                                                                                                                                                                                                                          	ThumbHeight         int                   `json:"thumb_height"`
                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                            InlineQueryResultArticle is an inline query response article.

                                                                                                                                                                                                                                                                            func NewInlineQueryResultArticle

                                                                                                                                                                                                                                                                            func NewInlineQueryResultArticle(id, title, messageText string) InlineQueryResultArticle

                                                                                                                                                                                                                                                                              NewInlineQueryResultArticle creates a new inline query article.

                                                                                                                                                                                                                                                                              func NewInlineQueryResultArticleHTML

                                                                                                                                                                                                                                                                              func NewInlineQueryResultArticleHTML(id, title, messageText string) InlineQueryResultArticle

                                                                                                                                                                                                                                                                                NewInlineQueryResultArticleHTML creates a new inline query article with HTML parsing.

                                                                                                                                                                                                                                                                                func NewInlineQueryResultArticleMarkdown

                                                                                                                                                                                                                                                                                func NewInlineQueryResultArticleMarkdown(id, title, messageText string) InlineQueryResultArticle

                                                                                                                                                                                                                                                                                  NewInlineQueryResultArticleMarkdown creates a new inline query article with Markdown parsing.

                                                                                                                                                                                                                                                                                  type InlineQueryResultAudio

                                                                                                                                                                                                                                                                                  type InlineQueryResultAudio struct {
                                                                                                                                                                                                                                                                                  	Type                string                `json:"type"`      // required
                                                                                                                                                                                                                                                                                  	ID                  string                `json:"id"`        // required
                                                                                                                                                                                                                                                                                  	URL                 string                `json:"audio_url"` // required
                                                                                                                                                                                                                                                                                  	Title               string                `json:"title"`     // required
                                                                                                                                                                                                                                                                                  	Caption             string                `json:"caption"`
                                                                                                                                                                                                                                                                                  	Performer           string                `json:"performer"`
                                                                                                                                                                                                                                                                                  	Duration            int                   `json:"audio_duration"`
                                                                                                                                                                                                                                                                                  	ReplyMarkup         *InlineKeyboardMarkup `json:"reply_markup,omitempty"`
                                                                                                                                                                                                                                                                                  	InputMessageContent interface{}           `json:"input_message_content,omitempty"`
                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                    InlineQueryResultAudio is an inline query response audio.

                                                                                                                                                                                                                                                                                    func NewInlineQueryResultAudio

                                                                                                                                                                                                                                                                                    func NewInlineQueryResultAudio(id, url, title string) InlineQueryResultAudio

                                                                                                                                                                                                                                                                                      NewInlineQueryResultAudio creates a new inline query audio.

                                                                                                                                                                                                                                                                                      type InlineQueryResultDocument

                                                                                                                                                                                                                                                                                      type InlineQueryResultDocument struct {
                                                                                                                                                                                                                                                                                      	Type                string                `json:"type"`  // required
                                                                                                                                                                                                                                                                                      	ID                  string                `json:"id"`    // required
                                                                                                                                                                                                                                                                                      	Title               string                `json:"title"` // required
                                                                                                                                                                                                                                                                                      	Caption             string                `json:"caption"`
                                                                                                                                                                                                                                                                                      	URL                 string                `json:"document_url"` // required
                                                                                                                                                                                                                                                                                      	MimeType            string                `json:"mime_type"`    // required
                                                                                                                                                                                                                                                                                      	Description         string                `json:"description"`
                                                                                                                                                                                                                                                                                      	ReplyMarkup         *InlineKeyboardMarkup `json:"reply_markup,omitempty"`
                                                                                                                                                                                                                                                                                      	InputMessageContent interface{}           `json:"input_message_content,omitempty"`
                                                                                                                                                                                                                                                                                      	ThumbURL            string                `json:"thumb_url"`
                                                                                                                                                                                                                                                                                      	ThumbWidth          int                   `json:"thumb_width"`
                                                                                                                                                                                                                                                                                      	ThumbHeight         int                   `json:"thumb_height"`
                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                        InlineQueryResultDocument is an inline query response document.

                                                                                                                                                                                                                                                                                        func NewInlineQueryResultDocument

                                                                                                                                                                                                                                                                                        func NewInlineQueryResultDocument(id, url, title, mimeType string) InlineQueryResultDocument

                                                                                                                                                                                                                                                                                          NewInlineQueryResultDocument creates a new inline query document.

                                                                                                                                                                                                                                                                                          type InlineQueryResultGIF

                                                                                                                                                                                                                                                                                          type InlineQueryResultGIF struct {
                                                                                                                                                                                                                                                                                          	Type                string                `json:"type"`    // required
                                                                                                                                                                                                                                                                                          	ID                  string                `json:"id"`      // required
                                                                                                                                                                                                                                                                                          	URL                 string                `json:"gif_url"` // required
                                                                                                                                                                                                                                                                                          	Width               int                   `json:"gif_width"`
                                                                                                                                                                                                                                                                                          	Height              int                   `json:"gif_height"`
                                                                                                                                                                                                                                                                                          	Duration            int                   `json:"gif_duration"`
                                                                                                                                                                                                                                                                                          	ThumbURL            string                `json:"thumb_url"`
                                                                                                                                                                                                                                                                                          	Title               string                `json:"title"`
                                                                                                                                                                                                                                                                                          	Caption             string                `json:"caption"`
                                                                                                                                                                                                                                                                                          	ReplyMarkup         *InlineKeyboardMarkup `json:"reply_markup,omitempty"`
                                                                                                                                                                                                                                                                                          	InputMessageContent interface{}           `json:"input_message_content,omitempty"`
                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                            InlineQueryResultGIF is an inline query response GIF.

                                                                                                                                                                                                                                                                                            func NewInlineQueryResultGIF

                                                                                                                                                                                                                                                                                            func NewInlineQueryResultGIF(id, url string) InlineQueryResultGIF

                                                                                                                                                                                                                                                                                              NewInlineQueryResultGIF creates a new inline query GIF.

                                                                                                                                                                                                                                                                                              type InlineQueryResultGame

                                                                                                                                                                                                                                                                                              type InlineQueryResultGame struct {
                                                                                                                                                                                                                                                                                              	Type          string                `json:"type"`
                                                                                                                                                                                                                                                                                              	ID            string                `json:"id"`
                                                                                                                                                                                                                                                                                              	GameShortName string                `json:"game_short_name"`
                                                                                                                                                                                                                                                                                              	ReplyMarkup   *InlineKeyboardMarkup `json:"reply_markup,omitempty"`
                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                InlineQueryResultGame is an inline query response game.

                                                                                                                                                                                                                                                                                                type InlineQueryResultLocation

                                                                                                                                                                                                                                                                                                type InlineQueryResultLocation struct {
                                                                                                                                                                                                                                                                                                	Type                string                `json:"type"`      // required
                                                                                                                                                                                                                                                                                                	ID                  string                `json:"id"`        // required
                                                                                                                                                                                                                                                                                                	Latitude            float64               `json:"latitude"`  // required
                                                                                                                                                                                                                                                                                                	Longitude           float64               `json:"longitude"` // required
                                                                                                                                                                                                                                                                                                	Title               string                `json:"title"`     // required
                                                                                                                                                                                                                                                                                                	ReplyMarkup         *InlineKeyboardMarkup `json:"reply_markup,omitempty"`
                                                                                                                                                                                                                                                                                                	InputMessageContent interface{}           `json:"input_message_content,omitempty"`
                                                                                                                                                                                                                                                                                                	ThumbURL            string                `json:"thumb_url"`
                                                                                                                                                                                                                                                                                                	ThumbWidth          int                   `json:"thumb_width"`
                                                                                                                                                                                                                                                                                                	ThumbHeight         int                   `json:"thumb_height"`
                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                  InlineQueryResultLocation is an inline query response location.

                                                                                                                                                                                                                                                                                                  func NewInlineQueryResultLocation

                                                                                                                                                                                                                                                                                                  func NewInlineQueryResultLocation(id, title string, latitude, longitude float64) InlineQueryResultLocation

                                                                                                                                                                                                                                                                                                    NewInlineQueryResultLocation creates a new inline query location.

                                                                                                                                                                                                                                                                                                    type InlineQueryResultMPEG4GIF

                                                                                                                                                                                                                                                                                                    type InlineQueryResultMPEG4GIF struct {
                                                                                                                                                                                                                                                                                                    	Type                string                `json:"type"`      // required
                                                                                                                                                                                                                                                                                                    	ID                  string                `json:"id"`        // required
                                                                                                                                                                                                                                                                                                    	URL                 string                `json:"mpeg4_url"` // required
                                                                                                                                                                                                                                                                                                    	Width               int                   `json:"mpeg4_width"`
                                                                                                                                                                                                                                                                                                    	Height              int                   `json:"mpeg4_height"`
                                                                                                                                                                                                                                                                                                    	Duration            int                   `json:"mpeg4_duration"`
                                                                                                                                                                                                                                                                                                    	ThumbURL            string                `json:"thumb_url"`
                                                                                                                                                                                                                                                                                                    	Title               string                `json:"title"`
                                                                                                                                                                                                                                                                                                    	Caption             string                `json:"caption"`
                                                                                                                                                                                                                                                                                                    	ReplyMarkup         *InlineKeyboardMarkup `json:"reply_markup,omitempty"`
                                                                                                                                                                                                                                                                                                    	InputMessageContent interface{}           `json:"input_message_content,omitempty"`
                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                      InlineQueryResultMPEG4GIF is an inline query response MPEG4 GIF.

                                                                                                                                                                                                                                                                                                      func NewInlineQueryResultMPEG4GIF

                                                                                                                                                                                                                                                                                                      func NewInlineQueryResultMPEG4GIF(id, url string) InlineQueryResultMPEG4GIF

                                                                                                                                                                                                                                                                                                        NewInlineQueryResultMPEG4GIF creates a new inline query MPEG4 GIF.

                                                                                                                                                                                                                                                                                                        type InlineQueryResultPhoto

                                                                                                                                                                                                                                                                                                        type InlineQueryResultPhoto struct {
                                                                                                                                                                                                                                                                                                        	Type                string                `json:"type"`      // required
                                                                                                                                                                                                                                                                                                        	ID                  string                `json:"id"`        // required
                                                                                                                                                                                                                                                                                                        	URL                 string                `json:"photo_url"` // required
                                                                                                                                                                                                                                                                                                        	MimeType            string                `json:"mime_type"`
                                                                                                                                                                                                                                                                                                        	Width               int                   `json:"photo_width"`
                                                                                                                                                                                                                                                                                                        	Height              int                   `json:"photo_height"`
                                                                                                                                                                                                                                                                                                        	ThumbURL            string                `json:"thumb_url"`
                                                                                                                                                                                                                                                                                                        	Title               string                `json:"title"`
                                                                                                                                                                                                                                                                                                        	Description         string                `json:"description"`
                                                                                                                                                                                                                                                                                                        	Caption             string                `json:"caption"`
                                                                                                                                                                                                                                                                                                        	ReplyMarkup         *InlineKeyboardMarkup `json:"reply_markup,omitempty"`
                                                                                                                                                                                                                                                                                                        	InputMessageContent interface{}           `json:"input_message_content,omitempty"`
                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                          InlineQueryResultPhoto is an inline query response photo.

                                                                                                                                                                                                                                                                                                          func NewInlineQueryResultPhoto

                                                                                                                                                                                                                                                                                                          func NewInlineQueryResultPhoto(id, url string) InlineQueryResultPhoto

                                                                                                                                                                                                                                                                                                            NewInlineQueryResultPhoto creates a new inline query photo.

                                                                                                                                                                                                                                                                                                            func NewInlineQueryResultPhotoWithThumb

                                                                                                                                                                                                                                                                                                            func NewInlineQueryResultPhotoWithThumb(id, url, thumb string) InlineQueryResultPhoto

                                                                                                                                                                                                                                                                                                              NewInlineQueryResultPhotoWithThumb creates a new inline query photo.

                                                                                                                                                                                                                                                                                                              type InlineQueryResultVideo

                                                                                                                                                                                                                                                                                                              type InlineQueryResultVideo struct {
                                                                                                                                                                                                                                                                                                              	Type                string                `json:"type"`      // required
                                                                                                                                                                                                                                                                                                              	ID                  string                `json:"id"`        // required
                                                                                                                                                                                                                                                                                                              	URL                 string                `json:"video_url"` // required
                                                                                                                                                                                                                                                                                                              	MimeType            string                `json:"mime_type"` // required
                                                                                                                                                                                                                                                                                                              	ThumbURL            string                `json:"thumb_url"`
                                                                                                                                                                                                                                                                                                              	Title               string                `json:"title"`
                                                                                                                                                                                                                                                                                                              	Caption             string                `json:"caption"`
                                                                                                                                                                                                                                                                                                              	Width               int                   `json:"video_width"`
                                                                                                                                                                                                                                                                                                              	Height              int                   `json:"video_height"`
                                                                                                                                                                                                                                                                                                              	Duration            int                   `json:"video_duration"`
                                                                                                                                                                                                                                                                                                              	Description         string                `json:"description"`
                                                                                                                                                                                                                                                                                                              	ReplyMarkup         *InlineKeyboardMarkup `json:"reply_markup,omitempty"`
                                                                                                                                                                                                                                                                                                              	InputMessageContent interface{}           `json:"input_message_content,omitempty"`
                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                InlineQueryResultVideo is an inline query response video.

                                                                                                                                                                                                                                                                                                                func NewInlineQueryResultVideo

                                                                                                                                                                                                                                                                                                                func NewInlineQueryResultVideo(id, url string) InlineQueryResultVideo

                                                                                                                                                                                                                                                                                                                  NewInlineQueryResultVideo creates a new inline query video.

                                                                                                                                                                                                                                                                                                                  type InlineQueryResultVoice

                                                                                                                                                                                                                                                                                                                  type InlineQueryResultVoice struct {
                                                                                                                                                                                                                                                                                                                  	Type                string                `json:"type"`      // required
                                                                                                                                                                                                                                                                                                                  	ID                  string                `json:"id"`        // required
                                                                                                                                                                                                                                                                                                                  	URL                 string                `json:"voice_url"` // required
                                                                                                                                                                                                                                                                                                                  	Title               string                `json:"title"`     // required
                                                                                                                                                                                                                                                                                                                  	Caption             string                `json:"caption"`
                                                                                                                                                                                                                                                                                                                  	Duration            int                   `json:"voice_duration"`
                                                                                                                                                                                                                                                                                                                  	ReplyMarkup         *InlineKeyboardMarkup `json:"reply_markup,omitempty"`
                                                                                                                                                                                                                                                                                                                  	InputMessageContent interface{}           `json:"input_message_content,omitempty"`
                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                    InlineQueryResultVoice is an inline query response voice.

                                                                                                                                                                                                                                                                                                                    func NewInlineQueryResultVoice

                                                                                                                                                                                                                                                                                                                    func NewInlineQueryResultVoice(id, url, title string) InlineQueryResultVoice

                                                                                                                                                                                                                                                                                                                      NewInlineQueryResultVoice creates a new inline query voice.

                                                                                                                                                                                                                                                                                                                      type InputContactMessageContent

                                                                                                                                                                                                                                                                                                                      type InputContactMessageContent struct {
                                                                                                                                                                                                                                                                                                                      	PhoneNumber string `json:"phone_number"`
                                                                                                                                                                                                                                                                                                                      	FirstName   string `json:"first_name"`
                                                                                                                                                                                                                                                                                                                      	LastName    string `json:"last_name"`
                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                        InputContactMessageContent contains a contact for displaying as an inline query result.

                                                                                                                                                                                                                                                                                                                        type InputLocationMessageContent

                                                                                                                                                                                                                                                                                                                        type InputLocationMessageContent struct {
                                                                                                                                                                                                                                                                                                                        	Latitude  float64 `json:"latitude"`
                                                                                                                                                                                                                                                                                                                        	Longitude float64 `json:"longitude"`
                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                          InputLocationMessageContent contains a location for displaying as an inline query result.

                                                                                                                                                                                                                                                                                                                          type InputMediaPhoto

                                                                                                                                                                                                                                                                                                                          type InputMediaPhoto struct {
                                                                                                                                                                                                                                                                                                                          	Type      string `json:"type"`
                                                                                                                                                                                                                                                                                                                          	Media     string `json:"media"`
                                                                                                                                                                                                                                                                                                                          	Caption   string `json:"caption"`
                                                                                                                                                                                                                                                                                                                          	ParseMode string `json:"parse_mode"`
                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                            InputMediaPhoto contains a photo for displaying as part of a media group.

                                                                                                                                                                                                                                                                                                                            func NewInputMediaPhoto

                                                                                                                                                                                                                                                                                                                            func NewInputMediaPhoto(media string) InputMediaPhoto

                                                                                                                                                                                                                                                                                                                              NewInputMediaPhoto creates a new InputMediaPhoto.

                                                                                                                                                                                                                                                                                                                              type InputMediaVideo

                                                                                                                                                                                                                                                                                                                              type InputMediaVideo struct {
                                                                                                                                                                                                                                                                                                                              	Type  string `json:"type"`
                                                                                                                                                                                                                                                                                                                              	Media string `json:"media"`
                                                                                                                                                                                                                                                                                                                              	// thumb intentionally missing as it is not currently compatible
                                                                                                                                                                                                                                                                                                                              	Caption           string `json:"caption"`
                                                                                                                                                                                                                                                                                                                              	ParseMode         string `json:"parse_mode"`
                                                                                                                                                                                                                                                                                                                              	Width             int    `json:"width"`
                                                                                                                                                                                                                                                                                                                              	Height            int    `json:"height"`
                                                                                                                                                                                                                                                                                                                              	Duration          int    `json:"duration"`
                                                                                                                                                                                                                                                                                                                              	SupportsStreaming bool   `json:"supports_streaming"`
                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                InputMediaVideo contains a video for displaying as part of a media group.

                                                                                                                                                                                                                                                                                                                                func NewInputMediaVideo

                                                                                                                                                                                                                                                                                                                                func NewInputMediaVideo(media string) InputMediaVideo

                                                                                                                                                                                                                                                                                                                                  NewInputMediaVideo creates a new InputMediaVideo.

                                                                                                                                                                                                                                                                                                                                  type InputTextMessageContent

                                                                                                                                                                                                                                                                                                                                  type InputTextMessageContent struct {
                                                                                                                                                                                                                                                                                                                                  	Text                  string `json:"message_text"`
                                                                                                                                                                                                                                                                                                                                  	ParseMode             string `json:"parse_mode"`
                                                                                                                                                                                                                                                                                                                                  	DisableWebPagePreview bool   `json:"disable_web_page_preview"`
                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                    InputTextMessageContent contains text for displaying as an inline query result.

                                                                                                                                                                                                                                                                                                                                    type InputVenueMessageContent

                                                                                                                                                                                                                                                                                                                                    type InputVenueMessageContent struct {
                                                                                                                                                                                                                                                                                                                                    	Latitude     float64 `json:"latitude"`
                                                                                                                                                                                                                                                                                                                                    	Longitude    float64 `json:"longitude"`
                                                                                                                                                                                                                                                                                                                                    	Title        string  `json:"title"`
                                                                                                                                                                                                                                                                                                                                    	Address      string  `json:"address"`
                                                                                                                                                                                                                                                                                                                                    	FoursquareID string  `json:"foursquare_id"`
                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                      InputVenueMessageContent contains a venue for displaying as an inline query result.

                                                                                                                                                                                                                                                                                                                                      type Invoice

                                                                                                                                                                                                                                                                                                                                      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"`
                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                        Invoice contains basic information about an invoice.

                                                                                                                                                                                                                                                                                                                                        type InvoiceConfig

                                                                                                                                                                                                                                                                                                                                        type InvoiceConfig struct {
                                                                                                                                                                                                                                                                                                                                        	BaseChat
                                                                                                                                                                                                                                                                                                                                        	Title               string          // required
                                                                                                                                                                                                                                                                                                                                        	Description         string          // required
                                                                                                                                                                                                                                                                                                                                        	Payload             string          // required
                                                                                                                                                                                                                                                                                                                                        	ProviderToken       string          // required
                                                                                                                                                                                                                                                                                                                                        	StartParameter      string          // required
                                                                                                                                                                                                                                                                                                                                        	Currency            string          // required
                                                                                                                                                                                                                                                                                                                                        	Prices              *[]LabeledPrice // required
                                                                                                                                                                                                                                                                                                                                        	PhotoURL            string
                                                                                                                                                                                                                                                                                                                                        	PhotoSize           int
                                                                                                                                                                                                                                                                                                                                        	PhotoWidth          int
                                                                                                                                                                                                                                                                                                                                        	PhotoHeight         int
                                                                                                                                                                                                                                                                                                                                        	NeedName            bool
                                                                                                                                                                                                                                                                                                                                        	NeedPhoneNumber     bool
                                                                                                                                                                                                                                                                                                                                        	NeedEmail           bool
                                                                                                                                                                                                                                                                                                                                        	NeedShippingAddress bool
                                                                                                                                                                                                                                                                                                                                        	IsFlexible          bool
                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                          InvoiceConfig contains information for sendInvoice request.

                                                                                                                                                                                                                                                                                                                                          func NewInvoice

                                                                                                                                                                                                                                                                                                                                          func NewInvoice(chatID int64, title, description, payload, providerToken, startParameter, currency string, prices *[]LabeledPrice) InvoiceConfig

                                                                                                                                                                                                                                                                                                                                            NewInvoice creates a new Invoice request to the user.

                                                                                                                                                                                                                                                                                                                                            type KeyboardButton

                                                                                                                                                                                                                                                                                                                                            type KeyboardButton struct {
                                                                                                                                                                                                                                                                                                                                            	Text            string `json:"text"`
                                                                                                                                                                                                                                                                                                                                            	RequestContact  bool   `json:"request_contact"`
                                                                                                                                                                                                                                                                                                                                            	RequestLocation bool   `json:"request_location"`
                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                              KeyboardButton is a button within a custom keyboard.

                                                                                                                                                                                                                                                                                                                                              func NewKeyboardButton

                                                                                                                                                                                                                                                                                                                                              func NewKeyboardButton(text string) KeyboardButton

                                                                                                                                                                                                                                                                                                                                                NewKeyboardButton creates a regular keyboard button.

                                                                                                                                                                                                                                                                                                                                                func NewKeyboardButtonContact

                                                                                                                                                                                                                                                                                                                                                func NewKeyboardButtonContact(text string) KeyboardButton

                                                                                                                                                                                                                                                                                                                                                  NewKeyboardButtonContact creates a keyboard button that requests user contact information upon click.

                                                                                                                                                                                                                                                                                                                                                  func NewKeyboardButtonLocation

                                                                                                                                                                                                                                                                                                                                                  func NewKeyboardButtonLocation(text string) KeyboardButton

                                                                                                                                                                                                                                                                                                                                                    NewKeyboardButtonLocation creates a keyboard button that requests user location information upon click.

                                                                                                                                                                                                                                                                                                                                                    func NewKeyboardButtonRow

                                                                                                                                                                                                                                                                                                                                                    func NewKeyboardButtonRow(buttons ...KeyboardButton) []KeyboardButton

                                                                                                                                                                                                                                                                                                                                                      NewKeyboardButtonRow creates a row of keyboard buttons.

                                                                                                                                                                                                                                                                                                                                                      type KickChatMemberConfig

                                                                                                                                                                                                                                                                                                                                                      type KickChatMemberConfig struct {
                                                                                                                                                                                                                                                                                                                                                      	ChatMemberConfig
                                                                                                                                                                                                                                                                                                                                                      	UntilDate int64
                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                        KickChatMemberConfig contains extra fields to kick user

                                                                                                                                                                                                                                                                                                                                                        type LabeledPrice

                                                                                                                                                                                                                                                                                                                                                        type LabeledPrice struct {
                                                                                                                                                                                                                                                                                                                                                        	Label  string `json:"label"`
                                                                                                                                                                                                                                                                                                                                                        	Amount int    `json:"amount"`
                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                          LabeledPrice represents a portion of the price for goods or services.

                                                                                                                                                                                                                                                                                                                                                          type Location

                                                                                                                                                                                                                                                                                                                                                          type Location struct {
                                                                                                                                                                                                                                                                                                                                                          	Longitude float64 `json:"longitude"`
                                                                                                                                                                                                                                                                                                                                                          	Latitude  float64 `json:"latitude"`
                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                            Location contains information about a place.

                                                                                                                                                                                                                                                                                                                                                            type LocationConfig

                                                                                                                                                                                                                                                                                                                                                            type LocationConfig struct {
                                                                                                                                                                                                                                                                                                                                                            	BaseChat
                                                                                                                                                                                                                                                                                                                                                            	Latitude  float64 // required
                                                                                                                                                                                                                                                                                                                                                            	Longitude float64 // required
                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                              LocationConfig contains information about a SendLocation request.

                                                                                                                                                                                                                                                                                                                                                              func NewLocation

                                                                                                                                                                                                                                                                                                                                                              func NewLocation(chatID int64, latitude float64, longitude float64) LocationConfig

                                                                                                                                                                                                                                                                                                                                                                NewLocation shares your location.

                                                                                                                                                                                                                                                                                                                                                                chatID is where to send it, latitude and longitude are coordinates.

                                                                                                                                                                                                                                                                                                                                                                type MediaGroupConfig

                                                                                                                                                                                                                                                                                                                                                                type MediaGroupConfig struct {
                                                                                                                                                                                                                                                                                                                                                                	BaseChat
                                                                                                                                                                                                                                                                                                                                                                	InputMedia []interface{}
                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                  MediaGroupConfig contains information about a sendMediaGroup request.

                                                                                                                                                                                                                                                                                                                                                                  func NewMediaGroup

                                                                                                                                                                                                                                                                                                                                                                  func NewMediaGroup(chatID int64, files []interface{}) MediaGroupConfig

                                                                                                                                                                                                                                                                                                                                                                    NewMediaGroup creates a new media group. Files should be an array of two to ten InputMediaPhoto or InputMediaVideo.

                                                                                                                                                                                                                                                                                                                                                                    type Message

                                                                                                                                                                                                                                                                                                                                                                    type Message struct {
                                                                                                                                                                                                                                                                                                                                                                    	MessageID             int                `json:"message_id"`
                                                                                                                                                                                                                                                                                                                                                                    	From                  *User              `json:"from"` // optional
                                                                                                                                                                                                                                                                                                                                                                    	Date                  int                `json:"date"`
                                                                                                                                                                                                                                                                                                                                                                    	Chat                  *Chat              `json:"chat"`
                                                                                                                                                                                                                                                                                                                                                                    	ForwardFrom           *User              `json:"forward_from"`            // optional
                                                                                                                                                                                                                                                                                                                                                                    	ForwardFromChat       *Chat              `json:"forward_from_chat"`       // optional
                                                                                                                                                                                                                                                                                                                                                                    	ForwardFromMessageID  int                `json:"forward_from_message_id"` // optional
                                                                                                                                                                                                                                                                                                                                                                    	ForwardDate           int                `json:"forward_date"`            // optional
                                                                                                                                                                                                                                                                                                                                                                    	ReplyToMessage        *Message           `json:"reply_to_message"`        // optional
                                                                                                                                                                                                                                                                                                                                                                    	EditDate              int                `json:"edit_date"`               // optional
                                                                                                                                                                                                                                                                                                                                                                    	Text                  string             `json:"text"`                    // optional
                                                                                                                                                                                                                                                                                                                                                                    	Entities              *[]MessageEntity   `json:"entities"`                // optional
                                                                                                                                                                                                                                                                                                                                                                    	Audio                 *Audio             `json:"audio"`                   // optional
                                                                                                                                                                                                                                                                                                                                                                    	Document              *Document          `json:"document"`                // optional
                                                                                                                                                                                                                                                                                                                                                                    	Animation             *ChatAnimation     `json:"animation"`               // optional
                                                                                                                                                                                                                                                                                                                                                                    	Game                  *Game              `json:"game"`                    // optional
                                                                                                                                                                                                                                                                                                                                                                    	Photo                 *[]PhotoSize       `json:"photo"`                   // optional
                                                                                                                                                                                                                                                                                                                                                                    	Sticker               *Sticker           `json:"sticker"`                 // optional
                                                                                                                                                                                                                                                                                                                                                                    	Video                 *Video             `json:"video"`                   // optional
                                                                                                                                                                                                                                                                                                                                                                    	VideoNote             *VideoNote         `json:"video_note"`              // optional
                                                                                                                                                                                                                                                                                                                                                                    	Voice                 *Voice             `json:"voice"`                   // optional
                                                                                                                                                                                                                                                                                                                                                                    	Caption               string             `json:"caption"`                 // optional
                                                                                                                                                                                                                                                                                                                                                                    	Contact               *Contact           `json:"contact"`                 // optional
                                                                                                                                                                                                                                                                                                                                                                    	Location              *Location          `json:"location"`                // optional
                                                                                                                                                                                                                                                                                                                                                                    	Venue                 *Venue             `json:"venue"`                   // optional
                                                                                                                                                                                                                                                                                                                                                                    	NewChatMembers        *[]User            `json:"new_chat_members"`        // optional
                                                                                                                                                                                                                                                                                                                                                                    	LeftChatMember        *User              `json:"left_chat_member"`        // optional
                                                                                                                                                                                                                                                                                                                                                                    	NewChatTitle          string             `json:"new_chat_title"`          // optional
                                                                                                                                                                                                                                                                                                                                                                    	NewChatPhoto          *[]PhotoSize       `json:"new_chat_photo"`          // optional
                                                                                                                                                                                                                                                                                                                                                                    	DeleteChatPhoto       bool               `json:"delete_chat_photo"`       // optional
                                                                                                                                                                                                                                                                                                                                                                    	GroupChatCreated      bool               `json:"group_chat_created"`      // optional
                                                                                                                                                                                                                                                                                                                                                                    	SuperGroupChatCreated bool               `json:"supergroup_chat_created"` // optional
                                                                                                                                                                                                                                                                                                                                                                    	ChannelChatCreated    bool               `json:"channel_chat_created"`    // optional
                                                                                                                                                                                                                                                                                                                                                                    	MigrateToChatID       int64              `json:"migrate_to_chat_id"`      // optional
                                                                                                                                                                                                                                                                                                                                                                    	MigrateFromChatID     int64              `json:"migrate_from_chat_id"`    // optional
                                                                                                                                                                                                                                                                                                                                                                    	PinnedMessage         *Message           `json:"pinned_message"`          // optional
                                                                                                                                                                                                                                                                                                                                                                    	Invoice               *Invoice           `json:"invoice"`                 // optional
                                                                                                                                                                                                                                                                                                                                                                    	SuccessfulPayment     *SuccessfulPayment `json:"successful_payment"`      // optional
                                                                                                                                                                                                                                                                                                                                                                    	PassportData          *PassportData      `json:"passport_data,omitempty"` // optional
                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                      Message is returned by almost every request, and contains data about almost anything.

                                                                                                                                                                                                                                                                                                                                                                      func (*Message) Command

                                                                                                                                                                                                                                                                                                                                                                      func (m *Message) Command() string

                                                                                                                                                                                                                                                                                                                                                                        Command checks if the message was a command and if it was, returns the command. If the Message was not a command, it returns an empty string.

                                                                                                                                                                                                                                                                                                                                                                        If the command contains the at name syntax, it is removed. Use CommandWithAt() if you do not want that.

                                                                                                                                                                                                                                                                                                                                                                        func (*Message) CommandArguments

                                                                                                                                                                                                                                                                                                                                                                        func (m *Message) CommandArguments() string

                                                                                                                                                                                                                                                                                                                                                                          CommandArguments checks if the message was a command and if it was, returns all text after the command name. If the Message was not a command, it returns an empty string.

                                                                                                                                                                                                                                                                                                                                                                          Note: The first character after the command name is omitted: - "/foo bar baz" yields "bar baz", not " bar baz" - "/foo-bar baz" yields "bar baz", too Even though the latter is not a command conforming to the spec, the API marks "/foo" as command entity.

                                                                                                                                                                                                                                                                                                                                                                          func (*Message) CommandWithAt

                                                                                                                                                                                                                                                                                                                                                                          func (m *Message) CommandWithAt() string

                                                                                                                                                                                                                                                                                                                                                                            CommandWithAt checks if the message was a command and if it was, returns the command. If the Message was not a command, it returns an empty string.

                                                                                                                                                                                                                                                                                                                                                                            If the command contains the at name syntax, it is not removed. Use Command() if you want that.

                                                                                                                                                                                                                                                                                                                                                                            func (*Message) IsCommand

                                                                                                                                                                                                                                                                                                                                                                            func (m *Message) IsCommand() bool

                                                                                                                                                                                                                                                                                                                                                                              IsCommand returns true if message starts with a "bot_command" entity.

                                                                                                                                                                                                                                                                                                                                                                              func (*Message) Time

                                                                                                                                                                                                                                                                                                                                                                              func (m *Message) Time() time.Time

                                                                                                                                                                                                                                                                                                                                                                                Time converts the message timestamp into a Time.

                                                                                                                                                                                                                                                                                                                                                                                type MessageConfig

                                                                                                                                                                                                                                                                                                                                                                                type MessageConfig struct {
                                                                                                                                                                                                                                                                                                                                                                                	BaseChat
                                                                                                                                                                                                                                                                                                                                                                                	Text                  string
                                                                                                                                                                                                                                                                                                                                                                                	ParseMode             string
                                                                                                                                                                                                                                                                                                                                                                                	DisableWebPagePreview bool
                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                  MessageConfig contains information about a SendMessage request.

                                                                                                                                                                                                                                                                                                                                                                                  func NewMessage

                                                                                                                                                                                                                                                                                                                                                                                  func NewMessage(chatID int64, text string) MessageConfig

                                                                                                                                                                                                                                                                                                                                                                                    NewMessage creates a new Message.

                                                                                                                                                                                                                                                                                                                                                                                    chatID is where to send it, text is the message text.

                                                                                                                                                                                                                                                                                                                                                                                    func NewMessageToChannel

                                                                                                                                                                                                                                                                                                                                                                                    func NewMessageToChannel(username string, text string) MessageConfig

                                                                                                                                                                                                                                                                                                                                                                                      NewMessageToChannel creates a new Message that is sent to a channel by username.

                                                                                                                                                                                                                                                                                                                                                                                      username is the username of the channel, text is the message text.

                                                                                                                                                                                                                                                                                                                                                                                      type MessageEntity

                                                                                                                                                                                                                                                                                                                                                                                      type MessageEntity struct {
                                                                                                                                                                                                                                                                                                                                                                                      	Type   string `json:"type"`
                                                                                                                                                                                                                                                                                                                                                                                      	Offset int    `json:"offset"`
                                                                                                                                                                                                                                                                                                                                                                                      	Length int    `json:"length"`
                                                                                                                                                                                                                                                                                                                                                                                      	URL    string `json:"url"`  // optional
                                                                                                                                                                                                                                                                                                                                                                                      	User   *User  `json:"user"` // optional
                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                        MessageEntity contains information about data in a Message.

                                                                                                                                                                                                                                                                                                                                                                                        func (MessageEntity) ParseURL

                                                                                                                                                                                                                                                                                                                                                                                        func (entity MessageEntity) ParseURL() (*url.URL, error)

                                                                                                                                                                                                                                                                                                                                                                                          ParseURL attempts to parse a URL contained within a MessageEntity.

                                                                                                                                                                                                                                                                                                                                                                                          type OrderInfo

                                                                                                                                                                                                                                                                                                                                                                                          type OrderInfo struct {
                                                                                                                                                                                                                                                                                                                                                                                          	Name            string           `json:"name,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                          	PhoneNumber     string           `json:"phone_number,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                          	Email           string           `json:"email,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                          	ShippingAddress *ShippingAddress `json:"shipping_address,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                            OrderInfo represents information about an order.

                                                                                                                                                                                                                                                                                                                                                                                            type PassportData

                                                                                                                                                                                                                                                                                                                                                                                            type PassportData struct {
                                                                                                                                                                                                                                                                                                                                                                                            	// Array with information about documents and other Telegram Passport
                                                                                                                                                                                                                                                                                                                                                                                            	// elements that was shared with the bot
                                                                                                                                                                                                                                                                                                                                                                                            	Data []EncryptedPassportElement `json:"data"`
                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                            	// Encrypted credentials required to decrypt the data
                                                                                                                                                                                                                                                                                                                                                                                            	Credentials *EncryptedCredentials `json:"credentials"`
                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                              PassportData contains information about Telegram Passport data shared with the bot by the user.

                                                                                                                                                                                                                                                                                                                                                                                              type PassportElementError

                                                                                                                                                                                                                                                                                                                                                                                              type PassportElementError interface{}

                                                                                                                                                                                                                                                                                                                                                                                                PassportElementError represents an error in the Telegram Passport element which was submitted that should be resolved by the user.

                                                                                                                                                                                                                                                                                                                                                                                                type PassportElementErrorDataField

                                                                                                                                                                                                                                                                                                                                                                                                type PassportElementErrorDataField struct {
                                                                                                                                                                                                                                                                                                                                                                                                	// Error source, must be data
                                                                                                                                                                                                                                                                                                                                                                                                	Source string `json:"source"`
                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                	// The section of the user's Telegram Passport which has the error, one
                                                                                                                                                                                                                                                                                                                                                                                                	// of "personal_details", "passport", "driver_license", "identity_card",
                                                                                                                                                                                                                                                                                                                                                                                                	// "internal_passport", "address"
                                                                                                                                                                                                                                                                                                                                                                                                	Type string `json:"type"`
                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                	// Name of the data field which has the error
                                                                                                                                                                                                                                                                                                                                                                                                	FieldName string `json:"field_name"`
                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                	// Base64-encoded data hash
                                                                                                                                                                                                                                                                                                                                                                                                	DataHash string `json:"data_hash"`
                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                	// Error message
                                                                                                                                                                                                                                                                                                                                                                                                	Message string `json:"message"`
                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                  PassportElementErrorDataField represents an issue in one of the data fields that was provided by the user. The error is considered resolved when the field's value changes.

                                                                                                                                                                                                                                                                                                                                                                                                  type PassportElementErrorFile

                                                                                                                                                                                                                                                                                                                                                                                                  type PassportElementErrorFile struct {
                                                                                                                                                                                                                                                                                                                                                                                                  	// Error source, must be file
                                                                                                                                                                                                                                                                                                                                                                                                  	Source string `json:"source"`
                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                  	// The section of the user's Telegram Passport which has the issue, one
                                                                                                                                                                                                                                                                                                                                                                                                  	// of "utility_bill", "bank_statement", "rental_agreement",
                                                                                                                                                                                                                                                                                                                                                                                                  	// "passport_registration", "temporary_registration"
                                                                                                                                                                                                                                                                                                                                                                                                  	Type string `json:"type"`
                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                  	// Base64-encoded file hash
                                                                                                                                                                                                                                                                                                                                                                                                  	FileHash string `json:"file_hash"`
                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                  	// Error message
                                                                                                                                                                                                                                                                                                                                                                                                  	Message string `json:"message"`
                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                    PassportElementErrorFile represents an issue with a document scan. The error is considered resolved when the file with the document scan changes.

                                                                                                                                                                                                                                                                                                                                                                                                    type PassportElementErrorFiles

                                                                                                                                                                                                                                                                                                                                                                                                    type PassportElementErrorFiles struct {
                                                                                                                                                                                                                                                                                                                                                                                                    	// Error source, must be files
                                                                                                                                                                                                                                                                                                                                                                                                    	Source string `json:"source"`
                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                    	// The section of the user's Telegram Passport which has the issue, one
                                                                                                                                                                                                                                                                                                                                                                                                    	// of "utility_bill", "bank_statement", "rental_agreement",
                                                                                                                                                                                                                                                                                                                                                                                                    	// "passport_registration", "temporary_registration"
                                                                                                                                                                                                                                                                                                                                                                                                    	Type string `json:"type"`
                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                    	// List of base64-encoded file hashes
                                                                                                                                                                                                                                                                                                                                                                                                    	FileHashes []string `json:"file_hashes"`
                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                    	// Error message
                                                                                                                                                                                                                                                                                                                                                                                                    	Message string `json:"message"`
                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                      PassportElementErrorFiles represents an issue with a list of scans. The error is considered resolved when the list of files containing the scans changes.

                                                                                                                                                                                                                                                                                                                                                                                                      type PassportElementErrorFrontSide

                                                                                                                                                                                                                                                                                                                                                                                                      type PassportElementErrorFrontSide struct {
                                                                                                                                                                                                                                                                                                                                                                                                      	// Error source, must be front_side
                                                                                                                                                                                                                                                                                                                                                                                                      	Source string `json:"source"`
                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                      	// The section of the user's Telegram Passport which has the issue, one
                                                                                                                                                                                                                                                                                                                                                                                                      	// of "passport", "driver_license", "identity_card", "internal_passport"
                                                                                                                                                                                                                                                                                                                                                                                                      	Type string `json:"type"`
                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                      	// Base64-encoded hash of the file with the front side of the document
                                                                                                                                                                                                                                                                                                                                                                                                      	FileHash string `json:"file_hash"`
                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                      	// Error message
                                                                                                                                                                                                                                                                                                                                                                                                      	Message string `json:"message"`
                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                        PassportElementErrorFrontSide represents an issue with the front side of a document. The error is considered resolved when the file with the front side of the document changes.

                                                                                                                                                                                                                                                                                                                                                                                                        type PassportElementErrorReverseSide

                                                                                                                                                                                                                                                                                                                                                                                                        type PassportElementErrorReverseSide struct {
                                                                                                                                                                                                                                                                                                                                                                                                        	// Error source, must be reverse_side
                                                                                                                                                                                                                                                                                                                                                                                                        	Source string `json:"source"`
                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                        	// The section of the user's Telegram Passport which has the issue, one
                                                                                                                                                                                                                                                                                                                                                                                                        	// of "driver_license", "identity_card"
                                                                                                                                                                                                                                                                                                                                                                                                        	Type string `json:"type"`
                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                        	// Base64-encoded hash of the file with the reverse side of the document
                                                                                                                                                                                                                                                                                                                                                                                                        	FileHash string `json:"file_hash"`
                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                        	// Error message
                                                                                                                                                                                                                                                                                                                                                                                                        	Message string `json:"message"`
                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                          PassportElementErrorReverseSide represents an issue with the reverse side of a document. The error is considered resolved when the file with reverse side of the document changes.

                                                                                                                                                                                                                                                                                                                                                                                                          type PassportElementErrorSelfie

                                                                                                                                                                                                                                                                                                                                                                                                          type PassportElementErrorSelfie struct {
                                                                                                                                                                                                                                                                                                                                                                                                          	// Error source, must be selfie
                                                                                                                                                                                                                                                                                                                                                                                                          	Source string `json:"source"`
                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                          	// The section of the user's Telegram Passport which has the issue, one
                                                                                                                                                                                                                                                                                                                                                                                                          	// of "passport", "driver_license", "identity_card", "internal_passport"
                                                                                                                                                                                                                                                                                                                                                                                                          	Type string `json:"type"`
                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                          	// Base64-encoded hash of the file with the selfie
                                                                                                                                                                                                                                                                                                                                                                                                          	FileHash string `json:"file_hash"`
                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                          	// Error message
                                                                                                                                                                                                                                                                                                                                                                                                          	Message string `json:"message"`
                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                            PassportElementErrorSelfie represents an issue with the selfie with a document. The error is considered resolved when the file with the selfie changes.

                                                                                                                                                                                                                                                                                                                                                                                                            type PassportFile

                                                                                                                                                                                                                                                                                                                                                                                                            type PassportFile struct {
                                                                                                                                                                                                                                                                                                                                                                                                            	// Unique identifier for this file
                                                                                                                                                                                                                                                                                                                                                                                                            	FileID string `json:"file_id"`
                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                            	// File size
                                                                                                                                                                                                                                                                                                                                                                                                            	FileSize int `json:"file_size"`
                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                            	// Unix time when the file was uploaded
                                                                                                                                                                                                                                                                                                                                                                                                            	FileDate int64 `json:"file_date"`
                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                              PassportFile represents a file uploaded to Telegram Passport. Currently all Telegram Passport files are in JPEG format when decrypted and don't exceed 10MB.

                                                                                                                                                                                                                                                                                                                                                                                                              type PassportRequestInfoConfig

                                                                                                                                                                                                                                                                                                                                                                                                              type PassportRequestInfoConfig struct {
                                                                                                                                                                                                                                                                                                                                                                                                              	BotID     int            `json:"bot_id"`
                                                                                                                                                                                                                                                                                                                                                                                                              	Scope     *PassportScope `json:"scope"`
                                                                                                                                                                                                                                                                                                                                                                                                              	Nonce     string         `json:"nonce"`
                                                                                                                                                                                                                                                                                                                                                                                                              	PublicKey string         `json:"public_key"`
                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                PassportRequestInfoConfig allows you to request passport info

                                                                                                                                                                                                                                                                                                                                                                                                                type PassportScope

                                                                                                                                                                                                                                                                                                                                                                                                                type PassportScope struct {
                                                                                                                                                                                                                                                                                                                                                                                                                	V    int                    `json:"v"`
                                                                                                                                                                                                                                                                                                                                                                                                                	Data []PassportScopeElement `json:"data"`
                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                  PassportScope is the requested scopes of data.

                                                                                                                                                                                                                                                                                                                                                                                                                  type PassportScopeElement

                                                                                                                                                                                                                                                                                                                                                                                                                  type PassportScopeElement interface {
                                                                                                                                                                                                                                                                                                                                                                                                                  	ScopeType() string
                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                    PassportScopeElement supports using one or one of several elements.

                                                                                                                                                                                                                                                                                                                                                                                                                    type PassportScopeElementOne

                                                                                                                                                                                                                                                                                                                                                                                                                    type PassportScopeElementOne struct {
                                                                                                                                                                                                                                                                                                                                                                                                                    	Type        string `json:"type"` // One of “personal_details”, “passport”, “driver_license”, “identity_card”, “internal_passport”, “address”, “utility_bill”, “bank_statement”, “rental_agreement”, “passport_registration”, “temporary_registration”, “phone_number”, “email”
                                                                                                                                                                                                                                                                                                                                                                                                                    	Selfie      bool   `json:"selfie"`
                                                                                                                                                                                                                                                                                                                                                                                                                    	Translation bool   `json:"translation"`
                                                                                                                                                                                                                                                                                                                                                                                                                    	NativeNames bool   `json:"native_name"`
                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                      PassportScopeElementOne requires the specified element be provided.

                                                                                                                                                                                                                                                                                                                                                                                                                      func (*PassportScopeElementOne) ScopeType

                                                                                                                                                                                                                                                                                                                                                                                                                      func (eo *PassportScopeElementOne) ScopeType() string

                                                                                                                                                                                                                                                                                                                                                                                                                        ScopeType is the scope type.

                                                                                                                                                                                                                                                                                                                                                                                                                        type PassportScopeElementOneOfSeveral

                                                                                                                                                                                                                                                                                                                                                                                                                        type PassportScopeElementOneOfSeveral struct {
                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                          PassportScopeElementOneOfSeveral allows you to request any one of the requested documents.

                                                                                                                                                                                                                                                                                                                                                                                                                          func (*PassportScopeElementOneOfSeveral) ScopeType

                                                                                                                                                                                                                                                                                                                                                                                                                          func (eo *PassportScopeElementOneOfSeveral) ScopeType() string

                                                                                                                                                                                                                                                                                                                                                                                                                            ScopeType is the scope type.

                                                                                                                                                                                                                                                                                                                                                                                                                            type PersonalDetails

                                                                                                                                                                                                                                                                                                                                                                                                                            type PersonalDetails struct {
                                                                                                                                                                                                                                                                                                                                                                                                                            	FirstName            string `json:"first_name"`
                                                                                                                                                                                                                                                                                                                                                                                                                            	LastName             string `json:"last_name"`
                                                                                                                                                                                                                                                                                                                                                                                                                            	MiddleName           string `json:"middle_name"`
                                                                                                                                                                                                                                                                                                                                                                                                                            	BirthDate            string `json:"birth_date"`
                                                                                                                                                                                                                                                                                                                                                                                                                            	Gender               string `json:"gender"`
                                                                                                                                                                                                                                                                                                                                                                                                                            	CountryCode          string `json:"country_code"`
                                                                                                                                                                                                                                                                                                                                                                                                                            	ResidenceCountryCode string `json:"residence_country_code"`
                                                                                                                                                                                                                                                                                                                                                                                                                            	FirstNameNative      string `json:"first_name_native"`
                                                                                                                                                                                                                                                                                                                                                                                                                            	LastNameNative       string `json:"last_name_native"`
                                                                                                                                                                                                                                                                                                                                                                                                                            	MiddleNameNative     string `json:"middle_name_native"`
                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                              PersonalDetails https://core.telegram.org/passport#personaldetails

                                                                                                                                                                                                                                                                                                                                                                                                                              type PhotoConfig

                                                                                                                                                                                                                                                                                                                                                                                                                              type PhotoConfig struct {
                                                                                                                                                                                                                                                                                                                                                                                                                              	BaseFile
                                                                                                                                                                                                                                                                                                                                                                                                                              	Caption   string
                                                                                                                                                                                                                                                                                                                                                                                                                              	ParseMode string
                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                PhotoConfig contains information about a SendPhoto request.

                                                                                                                                                                                                                                                                                                                                                                                                                                func NewPhotoShare

                                                                                                                                                                                                                                                                                                                                                                                                                                func NewPhotoShare(chatID int64, fileID string) PhotoConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                  NewPhotoShare shares an existing photo. You may use this to reshare an existing photo without reuploading it.

                                                                                                                                                                                                                                                                                                                                                                                                                                  chatID is where to send it, fileID is the ID of the file already uploaded.

                                                                                                                                                                                                                                                                                                                                                                                                                                  func NewPhotoUpload

                                                                                                                                                                                                                                                                                                                                                                                                                                  func NewPhotoUpload(chatID int64, file interface{}) PhotoConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                    NewPhotoUpload creates a new photo uploader.

                                                                                                                                                                                                                                                                                                                                                                                                                                    chatID is where to send it, file is a string path to the file, FileReader, or FileBytes.

                                                                                                                                                                                                                                                                                                                                                                                                                                    Note that you must send animated GIFs as a document.

                                                                                                                                                                                                                                                                                                                                                                                                                                    type PhotoSize

                                                                                                                                                                                                                                                                                                                                                                                                                                    type PhotoSize struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                    	FileID   string `json:"file_id"`
                                                                                                                                                                                                                                                                                                                                                                                                                                    	Width    int    `json:"width"`
                                                                                                                                                                                                                                                                                                                                                                                                                                    	Height   int    `json:"height"`
                                                                                                                                                                                                                                                                                                                                                                                                                                    	FileSize int    `json:"file_size"` // optional
                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                      PhotoSize contains information about photos.

                                                                                                                                                                                                                                                                                                                                                                                                                                      type PinChatMessageConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                      type PinChatMessageConfig struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                      	ChatID              int64
                                                                                                                                                                                                                                                                                                                                                                                                                                      	MessageID           int
                                                                                                                                                                                                                                                                                                                                                                                                                                      	DisableNotification bool
                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                        PinChatMessageConfig contains information of a message in a chat to pin.

                                                                                                                                                                                                                                                                                                                                                                                                                                        type PreCheckoutConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                        type PreCheckoutConfig struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                        	PreCheckoutQueryID string // required
                                                                                                                                                                                                                                                                                                                                                                                                                                        	OK                 bool   // required
                                                                                                                                                                                                                                                                                                                                                                                                                                        	ErrorMessage       string
                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                          PreCheckoutConfig conatins information for answerPreCheckoutQuery request.

                                                                                                                                                                                                                                                                                                                                                                                                                                          type 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,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                                                                          	OrderInfo        *OrderInfo `json:"order_info,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                            PreCheckoutQuery contains information about an incoming pre-checkout query.

                                                                                                                                                                                                                                                                                                                                                                                                                                            type PromoteChatMemberConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                            type PromoteChatMemberConfig struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                            	ChatMemberConfig
                                                                                                                                                                                                                                                                                                                                                                                                                                            	CanChangeInfo      *bool
                                                                                                                                                                                                                                                                                                                                                                                                                                            	CanPostMessages    *bool
                                                                                                                                                                                                                                                                                                                                                                                                                                            	CanEditMessages    *bool
                                                                                                                                                                                                                                                                                                                                                                                                                                            	CanDeleteMessages  *bool
                                                                                                                                                                                                                                                                                                                                                                                                                                            	CanInviteUsers     *bool
                                                                                                                                                                                                                                                                                                                                                                                                                                            	CanRestrictMembers *bool
                                                                                                                                                                                                                                                                                                                                                                                                                                            	CanPinMessages     *bool
                                                                                                                                                                                                                                                                                                                                                                                                                                            	CanPromoteMembers  *bool
                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                              PromoteChatMemberConfig contains fields to promote members of chat

                                                                                                                                                                                                                                                                                                                                                                                                                                              type ReplyKeyboardHide

                                                                                                                                                                                                                                                                                                                                                                                                                                              type ReplyKeyboardHide struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                              	HideKeyboard bool `json:"hide_keyboard"`
                                                                                                                                                                                                                                                                                                                                                                                                                                              	Selective    bool `json:"selective"` // optional
                                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                                ReplyKeyboardHide allows the Bot to hide a custom keyboard.

                                                                                                                                                                                                                                                                                                                                                                                                                                                func NewHideKeyboard

                                                                                                                                                                                                                                                                                                                                                                                                                                                func NewHideKeyboard(selective bool) ReplyKeyboardHide

                                                                                                                                                                                                                                                                                                                                                                                                                                                  NewHideKeyboard hides the keyboard, with the option for being selective or hiding for everyone.

                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ReplyKeyboardMarkup

                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ReplyKeyboardMarkup struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Keyboard        [][]KeyboardButton `json:"keyboard"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                  	ResizeKeyboard  bool               `json:"resize_keyboard"`   // optional
                                                                                                                                                                                                                                                                                                                                                                                                                                                  	OneTimeKeyboard bool               `json:"one_time_keyboard"` // optional
                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Selective       bool               `json:"selective"`         // optional
                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                    ReplyKeyboardMarkup allows the Bot to set a custom keyboard.

                                                                                                                                                                                                                                                                                                                                                                                                                                                    func NewReplyKeyboard

                                                                                                                                                                                                                                                                                                                                                                                                                                                    func NewReplyKeyboard(rows ...[]KeyboardButton) ReplyKeyboardMarkup

                                                                                                                                                                                                                                                                                                                                                                                                                                                      NewReplyKeyboard creates a new regular keyboard with sane defaults.

                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ReplyKeyboardRemove

                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ReplyKeyboardRemove struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                      	RemoveKeyboard bool `json:"remove_keyboard"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Selective      bool `json:"selective"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                        ReplyKeyboardRemove allows the Bot to hide a custom keyboard.

                                                                                                                                                                                                                                                                                                                                                                                                                                                        func NewRemoveKeyboard

                                                                                                                                                                                                                                                                                                                                                                                                                                                        func NewRemoveKeyboard(selective bool) ReplyKeyboardRemove

                                                                                                                                                                                                                                                                                                                                                                                                                                                          NewRemoveKeyboard hides the keyboard, with the option for being selective or hiding for everyone.

                                                                                                                                                                                                                                                                                                                                                                                                                                                          type ResponseParameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                          type ResponseParameters struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                          	MigrateToChatID int64 `json:"migrate_to_chat_id"` // optional
                                                                                                                                                                                                                                                                                                                                                                                                                                                          	RetryAfter      int   `json:"retry_after"`        // optional
                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                            ResponseParameters are various errors that can be returned in APIResponse.

                                                                                                                                                                                                                                                                                                                                                                                                                                                            type RestrictChatMemberConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                            type RestrictChatMemberConfig struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                            	ChatMemberConfig
                                                                                                                                                                                                                                                                                                                                                                                                                                                            	UntilDate             int64
                                                                                                                                                                                                                                                                                                                                                                                                                                                            	CanSendMessages       *bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                            	CanSendMediaMessages  *bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                            	CanSendOtherMessages  *bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                            	CanAddWebPagePreviews *bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                              RestrictChatMemberConfig contains fields to restrict members of chat

                                                                                                                                                                                                                                                                                                                                                                                                                                                              type SecureData

                                                                                                                                                                                                                                                                                                                                                                                                                                                              type SecureData map[string]*SecureValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                SecureData is a map of the fields and their encrypted values.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                type SecureValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                type SecureValue struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Data        *DataCredentials   `json:"data"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                	FrontSide   *FileCredentials   `json:"front_side"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                	ReverseSide *FileCredentials   `json:"reverse_side"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Selfie      *FileCredentials   `json:"selfie"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Translation []*FileCredentials `json:"translation"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Files       []*FileCredentials `json:"files"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  SecureValue contains encrypted values for a SecureData item.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type SetChatDescriptionConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type SetChatDescriptionConfig struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	ChatID      int64
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Description string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    SetChatDescriptionConfig contains information for change chat description.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type SetChatPhotoConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type SetChatPhotoConfig struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	BaseFile
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      SetChatPhotoConfig contains information for change chat photo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func NewSetChatPhotoShare

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func NewSetChatPhotoShare(chatID int64, fileID string) SetChatPhotoConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        NewSetChatPhotoShare shares an existing photo. You may use this to reshare an existing photo without reuploading it.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        chatID is where to send it, fileID is the ID of the file already uploaded.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func NewSetChatPhotoUpload

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func NewSetChatPhotoUpload(chatID int64, file interface{}) SetChatPhotoConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          NewSetChatPhotoUpload creates a new chat photo uploader.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          chatID is where to send it, file is a string path to the file, FileReader, or FileBytes.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Note that you must send animated GIFs as a document.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type SetChatTitleConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type SetChatTitleConfig struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	ChatID int64
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Title  string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            SetChatTitleConfig contains information for change chat title.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type SetGameScoreConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type SetGameScoreConfig struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	UserID             int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Score              int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Force              bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	DisableEditMessage bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	ChatID             int64
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	ChannelUsername    string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	MessageID          int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	InlineMessageID    string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              SetGameScoreConfig allows you to update the game score in a chat.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type 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"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ShippingAddress represents a shipping address.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type ShippingConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type ShippingConfig struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	ShippingQueryID string // required
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	OK              bool   // required
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	ShippingOptions *[]ShippingOption
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	ErrorMessage    string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ShippingConfig contains information for answerShippingQuery request.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ShippingOption

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ShippingOption struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	ID     string          `json:"id"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Title  string          `json:"title"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Prices *[]LabeledPrice `json:"prices"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ShippingOption represents one shipping option.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ShippingQuery

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ShippingQuery struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	ID              string           `json:"id"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	From            *User            `json:"from"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	InvoicePayload  string           `json:"invoice_payload"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	ShippingAddress *ShippingAddress `json:"shipping_address"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ShippingQuery contains information about an incoming shipping query.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type Sticker

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type Sticker struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	FileID    string     `json:"file_id"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Width     int        `json:"width"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Height    int        `json:"height"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Thumbnail *PhotoSize `json:"thumb"`     // optional
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Emoji     string     `json:"emoji"`     // optional
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	FileSize  int        `json:"file_size"` // optional
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	SetName   string     `json:"set_name"`  // optional
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Sticker contains information about a sticker.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type StickerConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type StickerConfig struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	BaseFile
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          StickerConfig contains information about a SendSticker request.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func NewStickerShare

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func NewStickerShare(chatID int64, fileID string) StickerConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            NewStickerShare shares an existing sticker. You may use this to reshare an existing sticker without reuploading it.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            chatID is where to send it, fileID is the ID of the sticker already uploaded.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func NewStickerUpload

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func NewStickerUpload(chatID int64, file interface{}) StickerConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              NewStickerUpload creates a new sticker uploader.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              chatID is where to send it, file is a string path to the file, FileReader, or FileBytes.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type SuccessfulPayment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type SuccessfulPayment struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Currency                string     `json:"currency"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	TotalAmount             int        `json:"total_amount"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	InvoicePayload          string     `json:"invoice_payload"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ShippingOptionID        string     `json:"shipping_option_id,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	OrderInfo               *OrderInfo `json:"order_info,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	TelegramPaymentChargeID string     `json:"telegram_payment_charge_id"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ProviderPaymentChargeID string     `json:"provider_payment_charge_id"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SuccessfulPayment contains basic information about a successful payment.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type UnpinChatMessageConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type UnpinChatMessageConfig struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	ChatID int64
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  UnpinChatMessageConfig contains information of chat to unpin.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type Update

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type Update struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	UpdateID           int                 `json:"update_id"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Message            *Message            `json:"message"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	EditedMessage      *Message            `json:"edited_message"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	ChannelPost        *Message            `json:"channel_post"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	EditedChannelPost  *Message            `json:"edited_channel_post"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	InlineQuery        *InlineQuery        `json:"inline_query"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	ChosenInlineResult *ChosenInlineResult `json:"chosen_inline_result"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	CallbackQuery      *CallbackQuery      `json:"callback_query"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	ShippingQuery      *ShippingQuery      `json:"shipping_query"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	PreCheckoutQuery   *PreCheckoutQuery   `json:"pre_checkout_query"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Update is an update response, from GetUpdates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type UpdateConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type UpdateConfig struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Offset  int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Limit   int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Timeout int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      UpdateConfig contains information about a GetUpdates request.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func NewUpdate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func NewUpdate(offset int) UpdateConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        NewUpdate gets updates since the last Offset.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        offset is the last Update ID to include. You likely want to set this to the last Update ID plus 1.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type UpdatesChannel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type UpdatesChannel <-chan Update

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          UpdatesChannel is the channel for getting updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (UpdatesChannel) Clear

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (ch UpdatesChannel) Clear()

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Clear discards all unprocessed incoming updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type User

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type User struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	ID           int    `json:"id"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	FirstName    string `json:"first_name"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	LastName     string `json:"last_name"`     // optional
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	UserName     string `json:"username"`      // optional
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	LanguageCode string `json:"language_code"` // optional
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	IsBot        bool   `json:"is_bot"`        // optional
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              User is a user on Telegram.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*User) String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (u *User) String() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                String displays a simple text version of a user.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                It is normally a user's username, but falls back to a first/last name as available.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type UserProfilePhotos

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type UserProfilePhotos struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	TotalCount int           `json:"total_count"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Photos     [][]PhotoSize `json:"photos"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  UserProfilePhotos contains a set of user profile photos.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type UserProfilePhotosConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type UserProfilePhotosConfig struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	UserID int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Offset int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Limit  int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    UserProfilePhotosConfig contains information about a GetUserProfilePhotos request.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func NewUserProfilePhotos

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func NewUserProfilePhotos(userID int) UserProfilePhotosConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      NewUserProfilePhotos gets user profile photos.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      userID is the ID of the user you wish to get profile photos from.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type Venue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type Venue struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Location     Location `json:"location"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Title        string   `json:"title"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Address      string   `json:"address"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	FoursquareID string   `json:"foursquare_id"` // optional
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Venue contains information about a venue, including its Location.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type VenueConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type VenueConfig struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	BaseChat
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Latitude     float64 // required
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Longitude    float64 // required
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Title        string  // required
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Address      string  // required
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	FoursquareID string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          VenueConfig contains information about a SendVenue request.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func NewVenue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func NewVenue(chatID int64, title, address string, latitude, longitude float64) VenueConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            NewVenue allows you to send a venue and its location.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type Video

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type Video struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	FileID    string     `json:"file_id"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Width     int        `json:"width"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Height    int        `json:"height"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Duration  int        `json:"duration"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Thumbnail *PhotoSize `json:"thumb"`     // optional
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	MimeType  string     `json:"mime_type"` // optional
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	FileSize  int        `json:"file_size"` // optional
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Video contains information about a video.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type VideoConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type VideoConfig struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	BaseFile
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Duration  int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Caption   string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ParseMode string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                VideoConfig contains information about a SendVideo request.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func NewVideoShare

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func NewVideoShare(chatID int64, fileID string) VideoConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  NewVideoShare shares an existing video. You may use this to reshare an existing video without reuploading it.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  chatID is where to send it, fileID is the ID of the video already uploaded.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func NewVideoUpload

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func NewVideoUpload(chatID int64, file interface{}) VideoConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NewVideoUpload creates a new video uploader.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    chatID is where to send it, file is a string path to the file, FileReader, or FileBytes.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type VideoNote

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type VideoNote struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	FileID    string     `json:"file_id"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Length    int        `json:"length"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Duration  int        `json:"duration"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Thumbnail *PhotoSize `json:"thumb"`     // optional
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	FileSize  int        `json:"file_size"` // optional
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      VideoNote contains information about a video.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type VideoNoteConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type VideoNoteConfig struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	BaseFile
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Duration int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Length   int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        VideoNoteConfig contains information about a SendVideoNote request.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func NewVideoNoteShare

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func NewVideoNoteShare(chatID int64, length int, fileID string) VideoNoteConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          NewVideoNoteShare shares an existing video. You may use this to reshare an existing video without reuploading it.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          chatID is where to send it, fileID is the ID of the video already uploaded.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func NewVideoNoteUpload

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func NewVideoNoteUpload(chatID int64, length int, file interface{}) VideoNoteConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            NewVideoNoteUpload creates a new video note uploader.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            chatID is where to send it, file is a string path to the file, FileReader, or FileBytes.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type Voice

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type Voice struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	FileID   string `json:"file_id"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Duration int    `json:"duration"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	MimeType string `json:"mime_type"` // optional
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	FileSize int    `json:"file_size"` // optional
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Voice contains information about a voice.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type VoiceConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type VoiceConfig struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	BaseFile
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Caption   string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ParseMode string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Duration  int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                VoiceConfig contains information about a SendVoice request.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func NewVoiceShare

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func NewVoiceShare(chatID int64, fileID string) VoiceConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  NewVoiceShare shares an existing voice. You may use this to reshare an existing voice without reuploading it.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  chatID is where to send it, fileID is the ID of the video already uploaded.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func NewVoiceUpload

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func NewVoiceUpload(chatID int64, file interface{}) VoiceConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NewVoiceUpload creates a new voice uploader.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    chatID is where to send it, file is a string path to the file, FileReader, or FileBytes.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type WebhookConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type WebhookConfig struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	URL            *url.URL
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Certificate    interface{}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	MaxConnections int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      WebhookConfig contains information about a SetWebhook request.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func NewWebhook

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func NewWebhook(link string) WebhookConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        NewWebhook creates a new webhook.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        link is the url parsable link you wish to get the updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Example
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Output:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func NewWebhookWithCert

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func NewWebhookWithCert(link string, file interface{}) WebhookConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          NewWebhookWithCert creates a new webhook with a certificate.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          link is the url you wish to get webhooks, file contains a string to a file, FileReader, or FileBytes.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type WebhookInfo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type WebhookInfo struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	URL                  string `json:"url"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	HasCustomCertificate bool   `json:"has_custom_certificate"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	PendingUpdateCount   int    `json:"pending_update_count"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	LastErrorDate        int    `json:"last_error_date"`    // optional
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	LastErrorMessage     string `json:"last_error_message"` // optional
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            WebhookInfo is information about a currently set webhook.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (WebhookInfo) IsSet

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (info WebhookInfo) IsSet() bool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              IsSet returns true if a webhook is currently set.