narayana/go-tdlib
3
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity
go-tdlib/client/function.go
c0re100 1011dc13ae
Update to TDLib master
2022-05-09 19:35:19 +08:00

14911 lines
458 KiB
Go
Executable file
Raw Blame History

// AUTOGENERATED
package client
import (
"errors"
)
// Returns the current authorization state; this is an offline request. For informational purposes only. Use updateAuthorizationState instead to maintain the current authorization state. Can be called before initialization
func (client *Client) GetAuthorizationState() (AuthorizationState, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getAuthorizationState",
},
Data: map[string]interface{}{},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
switch result.Type {
case TypeAuthorizationStateWaitTdlibParameters:
return UnmarshalAuthorizationStateWaitTdlibParameters(result.Data)
case TypeAuthorizationStateWaitEncryptionKey:
return UnmarshalAuthorizationStateWaitEncryptionKey(result.Data)
case TypeAuthorizationStateWaitPhoneNumber:
return UnmarshalAuthorizationStateWaitPhoneNumber(result.Data)
case TypeAuthorizationStateWaitCode:
return UnmarshalAuthorizationStateWaitCode(result.Data)
case TypeAuthorizationStateWaitOtherDeviceConfirmation:
return UnmarshalAuthorizationStateWaitOtherDeviceConfirmation(result.Data)
case TypeAuthorizationStateWaitRegistration:
return UnmarshalAuthorizationStateWaitRegistration(result.Data)
case TypeAuthorizationStateWaitPassword:
return UnmarshalAuthorizationStateWaitPassword(result.Data)
case TypeAuthorizationStateReady:
return UnmarshalAuthorizationStateReady(result.Data)
case TypeAuthorizationStateLoggingOut:
return UnmarshalAuthorizationStateLoggingOut(result.Data)
case TypeAuthorizationStateClosing:
return UnmarshalAuthorizationStateClosing(result.Data)
case TypeAuthorizationStateClosed:
return UnmarshalAuthorizationStateClosed(result.Data)
default:
return nil, errors.New("invalid type")
}
}
type SetTdlibParametersRequest struct {
// Parameters for TDLib initialization
Parameters *TdlibParameters `json:"parameters"`
}
// Sets the parameters for TDLib initialization. Works only when the current authorization state is authorizationStateWaitTdlibParameters
func (client *Client) SetTdlibParameters(req *SetTdlibParametersRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "setTdlibParameters",
},
Data: map[string]interface{}{
"parameters": req.Parameters,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type CheckDatabaseEncryptionKeyRequest struct {
// Encryption key to check or set up
EncryptionKey []byte `json:"encryption_key"`
}
// Checks the database encryption key for correctness. Works only when the current authorization state is authorizationStateWaitEncryptionKey
func (client *Client) CheckDatabaseEncryptionKey(req *CheckDatabaseEncryptionKeyRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "checkDatabaseEncryptionKey",
},
Data: map[string]interface{}{
"encryption_key": req.EncryptionKey,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type SetAuthenticationPhoneNumberRequest struct {
// The phone number of the user, in international format
PhoneNumber string `json:"phone_number"`
// Settings for the authentication of the user's phone number; pass null to use default settings
Settings *PhoneNumberAuthenticationSettings `json:"settings"`
}
// Sets the phone number of the user and sends an authentication code to the user. Works only when the current authorization state is authorizationStateWaitPhoneNumber, or if there is no pending authentication query and the current authorization state is authorizationStateWaitCode, authorizationStateWaitRegistration, or authorizationStateWaitPassword
func (client *Client) SetAuthenticationPhoneNumber(req *SetAuthenticationPhoneNumberRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "setAuthenticationPhoneNumber",
},
Data: map[string]interface{}{
"phone_number": req.PhoneNumber,
"settings": req.Settings,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
// Re-sends an authentication code to the user. Works only when the current authorization state is authorizationStateWaitCode, the next_code_type of the result is not null and the server-specified timeout has passed
func (client *Client) ResendAuthenticationCode() (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "resendAuthenticationCode",
},
Data: map[string]interface{}{},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type CheckAuthenticationCodeRequest struct {
// Authentication code to check
Code string `json:"code"`
}
// Checks the authentication code. Works only when the current authorization state is authorizationStateWaitCode
func (client *Client) CheckAuthenticationCode(req *CheckAuthenticationCodeRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "checkAuthenticationCode",
},
Data: map[string]interface{}{
"code": req.Code,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type RequestQrCodeAuthenticationRequest struct {
// List of user identifiers of other users currently using the application
OtherUserIds []int64 `json:"other_user_ids"`
}
// Requests QR code authentication by scanning a QR code on another logged in device. Works only when the current authorization state is authorizationStateWaitPhoneNumber, or if there is no pending authentication query and the current authorization state is authorizationStateWaitCode, authorizationStateWaitRegistration, or authorizationStateWaitPassword
func (client *Client) RequestQrCodeAuthentication(req *RequestQrCodeAuthenticationRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "requestQrCodeAuthentication",
},
Data: map[string]interface{}{
"other_user_ids": req.OtherUserIds,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type RegisterUserRequest struct {
// The first name of the user; 1-64 characters
FirstName string `json:"first_name"`
// The last name of the user; 0-64 characters
LastName string `json:"last_name"`
}
// Finishes user registration. Works only when the current authorization state is authorizationStateWaitRegistration
func (client *Client) RegisterUser(req *RegisterUserRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "registerUser",
},
Data: map[string]interface{}{
"first_name": req.FirstName,
"last_name": req.LastName,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type CheckAuthenticationPasswordRequest struct {
// The password to check
Password string `json:"password"`
}
// Checks the authentication password for correctness. Works only when the current authorization state is authorizationStateWaitPassword
func (client *Client) CheckAuthenticationPassword(req *CheckAuthenticationPasswordRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "checkAuthenticationPassword",
},
Data: map[string]interface{}{
"password": req.Password,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
// Requests to send a password recovery code to an email address that was previously set up. Works only when the current authorization state is authorizationStateWaitPassword
func (client *Client) RequestAuthenticationPasswordRecovery() (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "requestAuthenticationPasswordRecovery",
},
Data: map[string]interface{}{},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type CheckAuthenticationPasswordRecoveryCodeRequest struct {
// Recovery code to check
RecoveryCode string `json:"recovery_code"`
}
// Checks whether a password recovery code sent to an email address is valid. Works only when the current authorization state is authorizationStateWaitPassword
func (client *Client) CheckAuthenticationPasswordRecoveryCode(req *CheckAuthenticationPasswordRecoveryCodeRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "checkAuthenticationPasswordRecoveryCode",
},
Data: map[string]interface{}{
"recovery_code": req.RecoveryCode,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type RecoverAuthenticationPasswordRequest struct {
// Recovery code to check
RecoveryCode string `json:"recovery_code"`
// New password of the user; may be empty to remove the password
NewPassword string `json:"new_password"`
// New password hint; may be empty
NewHint string `json:"new_hint"`
}
// Recovers the password with a password recovery code sent to an email address that was previously set up. Works only when the current authorization state is authorizationStateWaitPassword
func (client *Client) RecoverAuthenticationPassword(req *RecoverAuthenticationPasswordRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "recoverAuthenticationPassword",
},
Data: map[string]interface{}{
"recovery_code": req.RecoveryCode,
"new_password": req.NewPassword,
"new_hint": req.NewHint,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type CheckAuthenticationBotTokenRequest struct {
// The bot token
Token string `json:"token"`
}
// Checks the authentication token of a bot; to log in as a bot. Works only when the current authorization state is authorizationStateWaitPhoneNumber. Can be used instead of setAuthenticationPhoneNumber and checkAuthenticationCode to log in
func (client *Client) CheckAuthenticationBotToken(req *CheckAuthenticationBotTokenRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "checkAuthenticationBotToken",
},
Data: map[string]interface{}{
"token": req.Token,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
// Closes the TDLib instance after a proper logout. Requires an available network connection. All local data will be destroyed. After the logout completes, updateAuthorizationState with authorizationStateClosed will be sent
func (client *Client) LogOut() (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "logOut",
},
Data: map[string]interface{}{},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
// Closes the TDLib instance. All databases will be flushed to disk and properly closed. After the close completes, updateAuthorizationState with authorizationStateClosed will be sent. Can be called before initialization
func (client *Client) Close() (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "close",
},
Data: map[string]interface{}{},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
// Closes the TDLib instance, destroying all local data without a proper logout. The current user session will remain in the list of all active sessions. All local data will be destroyed. After the destruction completes updateAuthorizationState with authorizationStateClosed will be sent. Can be called before authorization
func (client *Client) Destroy() (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "destroy",
},
Data: map[string]interface{}{},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type ConfirmQrCodeAuthenticationRequest struct {
// A link from a QR code. The link must be scanned by the in-app camera
Link string `json:"link"`
}
// Confirms QR code authentication on another device. Returns created session on success
func (client *Client) ConfirmQrCodeAuthentication(req *ConfirmQrCodeAuthenticationRequest) (*Session, error) {
result, err := client.Send(Request{
meta: meta{
Type: "confirmQrCodeAuthentication",
},
Data: map[string]interface{}{
"link": req.Link,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalSession(result.Data)
}
// Returns all updates needed to restore current TDLib state, i.e. all actual UpdateAuthorizationState/UpdateUser/UpdateNewChat and others. This is especially useful if TDLib is run in a separate process. Can be called before initialization
func (client *Client) GetCurrentState() (*Updates, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getCurrentState",
},
Data: map[string]interface{}{},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalUpdates(result.Data)
}
type SetDatabaseEncryptionKeyRequest struct {
// New encryption key
NewEncryptionKey []byte `json:"new_encryption_key"`
}
// Changes the database encryption key. Usually the encryption key is never changed and is stored in some OS keychain
func (client *Client) SetDatabaseEncryptionKey(req *SetDatabaseEncryptionKeyRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "setDatabaseEncryptionKey",
},
Data: map[string]interface{}{
"new_encryption_key": req.NewEncryptionKey,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
// Returns the current state of 2-step verification
func (client *Client) GetPasswordState() (*PasswordState, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getPasswordState",
},
Data: map[string]interface{}{},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalPasswordState(result.Data)
}
type SetPasswordRequest struct {
// Previous password of the user
OldPassword string `json:"old_password"`
// New password of the user; may be empty to remove the password
NewPassword string `json:"new_password"`
// New password hint; may be empty
NewHint string `json:"new_hint"`
// Pass true to change also the recovery email address
SetRecoveryEmailAddress bool `json:"set_recovery_email_address"`
// New recovery email address; may be empty
NewRecoveryEmailAddress string `json:"new_recovery_email_address"`
}
// Changes the password for the current user. If a new recovery email address is specified, then the change will not be applied until the new recovery email address is confirmed
func (client *Client) SetPassword(req *SetPasswordRequest) (*PasswordState, error) {
result, err := client.Send(Request{
meta: meta{
Type: "setPassword",
},
Data: map[string]interface{}{
"old_password": req.OldPassword,
"new_password": req.NewPassword,
"new_hint": req.NewHint,
"set_recovery_email_address": req.SetRecoveryEmailAddress,
"new_recovery_email_address": req.NewRecoveryEmailAddress,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalPasswordState(result.Data)
}
type GetRecoveryEmailAddressRequest struct {
// The password for the current user
Password string `json:"password"`
}
// Returns a 2-step verification recovery email address that was previously set up. This method can be used to verify a password provided by the user
func (client *Client) GetRecoveryEmailAddress(req *GetRecoveryEmailAddressRequest) (*RecoveryEmailAddress, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getRecoveryEmailAddress",
},
Data: map[string]interface{}{
"password": req.Password,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalRecoveryEmailAddress(result.Data)
}
type SetRecoveryEmailAddressRequest struct {
// Password of the current user
Password string `json:"password"`
// New recovery email address
NewRecoveryEmailAddress string `json:"new_recovery_email_address"`
}
// Changes the 2-step verification recovery email address of the user. If a new recovery email address is specified, then the change will not be applied until the new recovery email address is confirmed. If new_recovery_email_address is the same as the email address that is currently set up, this call succeeds immediately and aborts all other requests waiting for an email confirmation
func (client *Client) SetRecoveryEmailAddress(req *SetRecoveryEmailAddressRequest) (*PasswordState, error) {
result, err := client.Send(Request{
meta: meta{
Type: "setRecoveryEmailAddress",
},
Data: map[string]interface{}{
"password": req.Password,
"new_recovery_email_address": req.NewRecoveryEmailAddress,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalPasswordState(result.Data)
}
type CheckRecoveryEmailAddressCodeRequest struct {
// Verification code to check
Code string `json:"code"`
}
// Checks the 2-step verification recovery email address verification code
func (client *Client) CheckRecoveryEmailAddressCode(req *CheckRecoveryEmailAddressCodeRequest) (*PasswordState, error) {
result, err := client.Send(Request{
meta: meta{
Type: "checkRecoveryEmailAddressCode",
},
Data: map[string]interface{}{
"code": req.Code,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalPasswordState(result.Data)
}
// Resends the 2-step verification recovery email address verification code
func (client *Client) ResendRecoveryEmailAddressCode() (*PasswordState, error) {
result, err := client.Send(Request{
meta: meta{
Type: "resendRecoveryEmailAddressCode",
},
Data: map[string]interface{}{},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalPasswordState(result.Data)
}
// Requests to send a 2-step verification password recovery code to an email address that was previously set up
func (client *Client) RequestPasswordRecovery() (*EmailAddressAuthenticationCodeInfo, error) {
result, err := client.Send(Request{
meta: meta{
Type: "requestPasswordRecovery",
},
Data: map[string]interface{}{},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalEmailAddressAuthenticationCodeInfo(result.Data)
}
type CheckPasswordRecoveryCodeRequest struct {
// Recovery code to check
RecoveryCode string `json:"recovery_code"`
}
// Checks whether a 2-step verification password recovery code sent to an email address is valid
func (client *Client) CheckPasswordRecoveryCode(req *CheckPasswordRecoveryCodeRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "checkPasswordRecoveryCode",
},
Data: map[string]interface{}{
"recovery_code": req.RecoveryCode,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type RecoverPasswordRequest struct {
// Recovery code to check
RecoveryCode string `json:"recovery_code"`
// New password of the user; may be empty to remove the password
NewPassword string `json:"new_password"`
// New password hint; may be empty
NewHint string `json:"new_hint"`
}
// Recovers the 2-step verification password using a recovery code sent to an email address that was previously set up
func (client *Client) RecoverPassword(req *RecoverPasswordRequest) (*PasswordState, error) {
result, err := client.Send(Request{
meta: meta{
Type: "recoverPassword",
},
Data: map[string]interface{}{
"recovery_code": req.RecoveryCode,
"new_password": req.NewPassword,
"new_hint": req.NewHint,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalPasswordState(result.Data)
}
// Removes 2-step verification password without previous password and access to recovery email address. The password can't be reset immediately and the request needs to be repeated after the specified time
func (client *Client) ResetPassword() (ResetPasswordResult, error) {
result, err := client.Send(Request{
meta: meta{
Type: "resetPassword",
},
Data: map[string]interface{}{},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
switch result.Type {
case TypeResetPasswordResultOk:
return UnmarshalResetPasswordResultOk(result.Data)
case TypeResetPasswordResultPending:
return UnmarshalResetPasswordResultPending(result.Data)
case TypeResetPasswordResultDeclined:
return UnmarshalResetPasswordResultDeclined(result.Data)
default:
return nil, errors.New("invalid type")
}
}
// Cancels reset of 2-step verification password. The method can be called if passwordState.pending_reset_date > 0
func (client *Client) CancelPasswordReset() (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "cancelPasswordReset",
},
Data: map[string]interface{}{},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type CreateTemporaryPasswordRequest struct {
// Persistent user password
Password string `json:"password"`
// Time during which the temporary password will be valid, in seconds; must be between 60 and 86400
ValidFor int32 `json:"valid_for"`
}
// Creates a new temporary password for processing payments
func (client *Client) CreateTemporaryPassword(req *CreateTemporaryPasswordRequest) (*TemporaryPasswordState, error) {
result, err := client.Send(Request{
meta: meta{
Type: "createTemporaryPassword",
},
Data: map[string]interface{}{
"password": req.Password,
"valid_for": req.ValidFor,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalTemporaryPasswordState(result.Data)
}
// Returns information about the current temporary password
func (client *Client) GetTemporaryPasswordState() (*TemporaryPasswordState, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getTemporaryPasswordState",
},
Data: map[string]interface{}{},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalTemporaryPasswordState(result.Data)
}
// Returns the current user
func (client *Client) GetMe() (*User, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getMe",
},
Data: map[string]interface{}{},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalUser(result.Data)
}
type GetUserRequest struct {
// User identifier
UserId int64 `json:"user_id"`
}
// Returns information about a user by their identifier. This is an offline request if the current user is not a bot
func (client *Client) GetUser(req *GetUserRequest) (*User, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getUser",
},
Data: map[string]interface{}{
"user_id": req.UserId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalUser(result.Data)
}
type GetUserFullInfoRequest struct {
// User identifier
UserId int64 `json:"user_id"`
}
// Returns full information about a user by their identifier
func (client *Client) GetUserFullInfo(req *GetUserFullInfoRequest) (*UserFullInfo, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getUserFullInfo",
},
Data: map[string]interface{}{
"user_id": req.UserId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalUserFullInfo(result.Data)
}
type GetBasicGroupRequest struct {
// Basic group identifier
BasicGroupId int64 `json:"basic_group_id"`
}
// Returns information about a basic group by its identifier. This is an offline request if the current user is not a bot
func (client *Client) GetBasicGroup(req *GetBasicGroupRequest) (*BasicGroup, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getBasicGroup",
},
Data: map[string]interface{}{
"basic_group_id": req.BasicGroupId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalBasicGroup(result.Data)
}
type GetBasicGroupFullInfoRequest struct {
// Basic group identifier
BasicGroupId int64 `json:"basic_group_id"`
}
// Returns full information about a basic group by its identifier
func (client *Client) GetBasicGroupFullInfo(req *GetBasicGroupFullInfoRequest) (*BasicGroupFullInfo, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getBasicGroupFullInfo",
},
Data: map[string]interface{}{
"basic_group_id": req.BasicGroupId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalBasicGroupFullInfo(result.Data)
}
type GetSupergroupRequest struct {
// Supergroup or channel identifier
SupergroupId int64 `json:"supergroup_id"`
}
// Returns information about a supergroup or a channel by its identifier. This is an offline request if the current user is not a bot
func (client *Client) GetSupergroup(req *GetSupergroupRequest) (*Supergroup, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getSupergroup",
},
Data: map[string]interface{}{
"supergroup_id": req.SupergroupId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalSupergroup(result.Data)
}
type GetSupergroupFullInfoRequest struct {
// Supergroup or channel identifier
SupergroupId int64 `json:"supergroup_id"`
}
// Returns full information about a supergroup or a channel by its identifier, cached for up to 1 minute
func (client *Client) GetSupergroupFullInfo(req *GetSupergroupFullInfoRequest) (*SupergroupFullInfo, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getSupergroupFullInfo",
},
Data: map[string]interface{}{
"supergroup_id": req.SupergroupId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalSupergroupFullInfo(result.Data)
}
type GetSecretChatRequest struct {
// Secret chat identifier
SecretChatId int32 `json:"secret_chat_id"`
}
// Returns information about a secret chat by its identifier. This is an offline request
func (client *Client) GetSecretChat(req *GetSecretChatRequest) (*SecretChat, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getSecretChat",
},
Data: map[string]interface{}{
"secret_chat_id": req.SecretChatId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalSecretChat(result.Data)
}
type GetChatRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
}
// Returns information about a chat by its identifier, this is an offline request if the current user is not a bot
func (client *Client) GetChat(req *GetChatRequest) (*Chat, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getChat",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalChat(result.Data)
}
type GetMessageRequest struct {
// Identifier of the chat the message belongs to
ChatId int64 `json:"chat_id"`
// Identifier of the message to get
MessageId int64 `json:"message_id"`
}
// Returns information about a message
func (client *Client) GetMessage(req *GetMessageRequest) (*Message, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getMessage",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"message_id": req.MessageId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalMessage(result.Data)
}
type GetMessageLocallyRequest struct {
// Identifier of the chat the message belongs to
ChatId int64 `json:"chat_id"`
// Identifier of the message to get
MessageId int64 `json:"message_id"`
}
// Returns information about a message, if it is available without sending network request. This is an offline request
func (client *Client) GetMessageLocally(req *GetMessageLocallyRequest) (*Message, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getMessageLocally",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"message_id": req.MessageId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalMessage(result.Data)
}
type GetRepliedMessageRequest struct {
// Identifier of the chat the message belongs to
ChatId int64 `json:"chat_id"`
// Identifier of the reply message
MessageId int64 `json:"message_id"`
}
// Returns information about a message that is replied by a given message. Also returns the pinned message, the game message, and the invoice message for messages of the types messagePinMessage, messageGameScore, and messagePaymentSuccessful respectively
func (client *Client) GetRepliedMessage(req *GetRepliedMessageRequest) (*Message, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getRepliedMessage",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"message_id": req.MessageId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalMessage(result.Data)
}
type GetChatPinnedMessageRequest struct {
// Identifier of the chat the message belongs to
ChatId int64 `json:"chat_id"`
}
// Returns information about a newest pinned message in the chat
func (client *Client) GetChatPinnedMessage(req *GetChatPinnedMessageRequest) (*Message, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getChatPinnedMessage",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalMessage(result.Data)
}
type GetCallbackQueryMessageRequest struct {
// Identifier of the chat the message belongs to
ChatId int64 `json:"chat_id"`
// Message identifier
MessageId int64 `json:"message_id"`
// Identifier of the callback query
CallbackQueryId JsonInt64 `json:"callback_query_id"`
}
// Returns information about a message with the callback button that originated a callback query; for bots only
func (client *Client) GetCallbackQueryMessage(req *GetCallbackQueryMessageRequest) (*Message, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getCallbackQueryMessage",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"message_id": req.MessageId,
"callback_query_id": req.CallbackQueryId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalMessage(result.Data)
}
type GetMessagesRequest struct {
// Identifier of the chat the messages belong to
ChatId int64 `json:"chat_id"`
// Identifiers of the messages to get
MessageIds []int64 `json:"message_ids"`
}
// Returns information about messages. If a message is not found, returns null on the corresponding position of the result
func (client *Client) GetMessages(req *GetMessagesRequest) (*Messages, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getMessages",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"message_ids": req.MessageIds,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalMessages(result.Data)
}
type GetMessageThreadRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
// Identifier of the message
MessageId int64 `json:"message_id"`
}
// Returns information about a message thread. Can be used only if message.can_get_message_thread == true
func (client *Client) GetMessageThread(req *GetMessageThreadRequest) (*MessageThreadInfo, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getMessageThread",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"message_id": req.MessageId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalMessageThreadInfo(result.Data)
}
type GetMessageViewersRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
// Identifier of the message
MessageId int64 `json:"message_id"`
}
// Returns viewers of a recent outgoing message in a basic group or a supergroup chat. For video notes and voice notes only users, opened content of the message, are returned. The method can be called if message.can_get_viewers == true
func (client *Client) GetMessageViewers(req *GetMessageViewersRequest) (*Users, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getMessageViewers",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"message_id": req.MessageId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalUsers(result.Data)
}
type GetFileRequest struct {
// Identifier of the file to get
FileId int32 `json:"file_id"`
}
// Returns information about a file; this is an offline request
func (client *Client) GetFile(req *GetFileRequest) (*File, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getFile",
},
Data: map[string]interface{}{
"file_id": req.FileId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalFile(result.Data)
}
type GetRemoteFileRequest struct {
// Remote identifier of the file to get
RemoteFileId string `json:"remote_file_id"`
// File type; pass null if unknown
FileType FileType `json:"file_type"`
}
// Returns information about a file by its remote ID; this is an offline request. Can be used to register a URL as a file for further uploading, or sending as a message. Even the request succeeds, the file can be used only if it is still accessible to the user. For example, if the file is from a message, then the message must be not deleted and accessible to the user. If the file database is disabled, then the corresponding object with the file must be preloaded by the application
func (client *Client) GetRemoteFile(req *GetRemoteFileRequest) (*File, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getRemoteFile",
},
Data: map[string]interface{}{
"remote_file_id": req.RemoteFileId,
"file_type": req.FileType,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalFile(result.Data)
}
type LoadChatsRequest struct {
// The chat list in which to load chats; pass null to load chats from the main chat list
ChatList ChatList `json:"chat_list"`
// The maximum number of chats to be loaded. For optimal performance, the number of loaded chats is chosen by TDLib and can be smaller than the specified limit, even if the end of the list is not reached
Limit int32 `json:"limit"`
}
// Loads more chats from a chat list. The loaded chats and their positions in the chat list will be sent through updates. Chats are sorted by the pair (chat.position.order, chat.id) in descending order. Returns a 404 error if all chats have been loaded
func (client *Client) LoadChats(req *LoadChatsRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "loadChats",
},
Data: map[string]interface{}{
"chat_list": req.ChatList,
"limit": req.Limit,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type GetChatsRequest struct {
// The chat list in which to return chats; pass null to get chats from the main chat list
ChatList ChatList `json:"chat_list"`
// The maximum number of chats to be returned
Limit int32 `json:"limit"`
}
// Returns an ordered list of chats from the beginning of a chat list. For informational purposes only. Use loadChats and updates processing instead to maintain chat lists in a consistent state
func (client *Client) GetChats(req *GetChatsRequest) (*Chats, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getChats",
},
Data: map[string]interface{}{
"chat_list": req.ChatList,
"limit": req.Limit,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalChats(result.Data)
}
type SearchPublicChatRequest struct {
// Username to be resolved
Username string `json:"username"`
}
// Searches a public chat by its username. Currently, only private chats, supergroups and channels can be public. Returns the chat if found; otherwise an error is returned
func (client *Client) SearchPublicChat(req *SearchPublicChatRequest) (*Chat, error) {
result, err := client.Send(Request{
meta: meta{
Type: "searchPublicChat",
},
Data: map[string]interface{}{
"username": req.Username,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalChat(result.Data)
}
type SearchPublicChatsRequest struct {
// Query to search for
Query string `json:"query"`
}
// Searches public chats by looking for specified query in their username and title. Currently, only private chats, supergroups and channels can be public. Returns a meaningful number of results. Excludes private chats with contacts and chats from the chat list from the results
func (client *Client) SearchPublicChats(req *SearchPublicChatsRequest) (*Chats, error) {
result, err := client.Send(Request{
meta: meta{
Type: "searchPublicChats",
},
Data: map[string]interface{}{
"query": req.Query,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalChats(result.Data)
}
type SearchChatsRequest struct {
// Query to search for. If the query is empty, returns up to 50 recently found chats
Query string `json:"query"`
// The maximum number of chats to be returned
Limit int32 `json:"limit"`
}
// Searches for the specified query in the title and username of already known chats, this is an offline request. Returns chats in the order seen in the main chat list
func (client *Client) SearchChats(req *SearchChatsRequest) (*Chats, error) {
result, err := client.Send(Request{
meta: meta{
Type: "searchChats",
},
Data: map[string]interface{}{
"query": req.Query,
"limit": req.Limit,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalChats(result.Data)
}
type SearchChatsOnServerRequest struct {
// Query to search for
Query string `json:"query"`
// The maximum number of chats to be returned
Limit int32 `json:"limit"`
}
// Searches for the specified query in the title and username of already known chats via request to the server. Returns chats in the order seen in the main chat list
func (client *Client) SearchChatsOnServer(req *SearchChatsOnServerRequest) (*Chats, error) {
result, err := client.Send(Request{
meta: meta{
Type: "searchChatsOnServer",
},
Data: map[string]interface{}{
"query": req.Query,
"limit": req.Limit,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalChats(result.Data)
}
type SearchChatsNearbyRequest struct {
// Current user location
Location *Location `json:"location"`
}
// Returns a list of users and location-based supergroups nearby. The list of users nearby will be updated for 60 seconds after the request by the updates updateUsersNearby. The request must be sent again every 25 seconds with adjusted location to not miss new chats
func (client *Client) SearchChatsNearby(req *SearchChatsNearbyRequest) (*ChatsNearby, error) {
result, err := client.Send(Request{
meta: meta{
Type: "searchChatsNearby",
},
Data: map[string]interface{}{
"location": req.Location,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalChatsNearby(result.Data)
}
type GetTopChatsRequest struct {
// Category of chats to be returned
Category TopChatCategory `json:"category"`
// The maximum number of chats to be returned; up to 30
Limit int32 `json:"limit"`
}
// Returns a list of frequently used chats. Supported only if the chat info database is enabled
func (client *Client) GetTopChats(req *GetTopChatsRequest) (*Chats, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getTopChats",
},
Data: map[string]interface{}{
"category": req.Category,
"limit": req.Limit,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalChats(result.Data)
}
type RemoveTopChatRequest struct {
// Category of frequently used chats
Category TopChatCategory `json:"category"`
// Chat identifier
ChatId int64 `json:"chat_id"`
}
// Removes a chat from the list of frequently used chats. Supported only if the chat info database is enabled
func (client *Client) RemoveTopChat(req *RemoveTopChatRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "removeTopChat",
},
Data: map[string]interface{}{
"category": req.Category,
"chat_id": req.ChatId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type AddRecentlyFoundChatRequest struct {
// Identifier of the chat to add
ChatId int64 `json:"chat_id"`
}
// Adds a chat to the list of recently found chats. The chat is added to the beginning of the list. If the chat is already in the list, it will be removed from the list first
func (client *Client) AddRecentlyFoundChat(req *AddRecentlyFoundChatRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "addRecentlyFoundChat",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type RemoveRecentlyFoundChatRequest struct {
// Identifier of the chat to be removed
ChatId int64 `json:"chat_id"`
}
// Removes a chat from the list of recently found chats
func (client *Client) RemoveRecentlyFoundChat(req *RemoveRecentlyFoundChatRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "removeRecentlyFoundChat",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
// Clears the list of recently found chats
func (client *Client) ClearRecentlyFoundChats() (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "clearRecentlyFoundChats",
},
Data: map[string]interface{}{},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type GetRecentlyOpenedChatsRequest struct {
// The maximum number of chats to be returned
Limit int32 `json:"limit"`
}
// Returns recently opened chats, this is an offline request. Returns chats in the order of last opening
func (client *Client) GetRecentlyOpenedChats(req *GetRecentlyOpenedChatsRequest) (*Chats, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getRecentlyOpenedChats",
},
Data: map[string]interface{}{
"limit": req.Limit,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalChats(result.Data)
}
type CheckChatUsernameRequest struct {
// Chat identifier; must be identifier of a supergroup chat, or a channel chat, or a private chat with self, or zero if the chat is being created
ChatId int64 `json:"chat_id"`
// Username to be checked
Username string `json:"username"`
}
// Checks whether a username can be set for a chat
func (client *Client) CheckChatUsername(req *CheckChatUsernameRequest) (CheckChatUsernameResult, error) {
result, err := client.Send(Request{
meta: meta{
Type: "checkChatUsername",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"username": req.Username,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
switch result.Type {
case TypeCheckChatUsernameResultOk:
return UnmarshalCheckChatUsernameResultOk(result.Data)
case TypeCheckChatUsernameResultUsernameInvalid:
return UnmarshalCheckChatUsernameResultUsernameInvalid(result.Data)
case TypeCheckChatUsernameResultUsernameOccupied:
return UnmarshalCheckChatUsernameResultUsernameOccupied(result.Data)
case TypeCheckChatUsernameResultPublicChatsTooMuch:
return UnmarshalCheckChatUsernameResultPublicChatsTooMuch(result.Data)
case TypeCheckChatUsernameResultPublicGroupsUnavailable:
return UnmarshalCheckChatUsernameResultPublicGroupsUnavailable(result.Data)
default:
return nil, errors.New("invalid type")
}
}
type GetCreatedPublicChatsRequest struct {
// Type of the public chats to return
Type PublicChatType `json:"type"`
}
// Returns a list of public chats of the specified type, owned by the user
func (client *Client) GetCreatedPublicChats(req *GetCreatedPublicChatsRequest) (*Chats, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getCreatedPublicChats",
},
Data: map[string]interface{}{
"type": req.Type,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalChats(result.Data)
}
type CheckCreatedPublicChatsLimitRequest struct {
// Type of the public chats, for which to check the limit
Type PublicChatType `json:"type"`
}
// Checks whether the maximum number of owned public chats has been reached. Returns corresponding error if the limit was reached
func (client *Client) CheckCreatedPublicChatsLimit(req *CheckCreatedPublicChatsLimitRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "checkCreatedPublicChatsLimit",
},
Data: map[string]interface{}{
"type": req.Type,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
// Returns a list of basic group and supergroup chats, which can be used as a discussion group for a channel. Returned basic group chats must be first upgraded to supergroups before they can be set as a discussion group. To set a returned supergroup as a discussion group, access to its old messages must be enabled using toggleSupergroupIsAllHistoryAvailable first
func (client *Client) GetSuitableDiscussionChats() (*Chats, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getSuitableDiscussionChats",
},
Data: map[string]interface{}{},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalChats(result.Data)
}
// Returns a list of recently inactive supergroups and channels. Can be used when user reaches limit on the number of joined supergroups and channels and receives CHANNELS_TOO_MUCH error
func (client *Client) GetInactiveSupergroupChats() (*Chats, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getInactiveSupergroupChats",
},
Data: map[string]interface{}{},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalChats(result.Data)
}
type GetGroupsInCommonRequest struct {
// User identifier
UserId int64 `json:"user_id"`
// Chat identifier starting from which to return chats; use 0 for the first request
OffsetChatId int64 `json:"offset_chat_id"`
// The maximum number of chats to be returned; up to 100
Limit int32 `json:"limit"`
}
// Returns a list of common group chats with a given user. Chats are sorted by their type and creation date
func (client *Client) GetGroupsInCommon(req *GetGroupsInCommonRequest) (*Chats, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getGroupsInCommon",
},
Data: map[string]interface{}{
"user_id": req.UserId,
"offset_chat_id": req.OffsetChatId,
"limit": req.Limit,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalChats(result.Data)
}
type GetChatHistoryRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
// Identifier of the message starting from which history must be fetched; use 0 to get results from the last message
FromMessageId int64 `json:"from_message_id"`
// Specify 0 to get results from exactly the from_message_id or a negative offset up to 99 to get additionally some newer messages
Offset int32 `json:"offset"`
// The maximum number of messages to be returned; must be positive and can't be greater than 100. If the offset is negative, the limit must be greater than or equal to -offset. For optimal performance, the number of returned messages is chosen by TDLib and can be smaller than the specified limit
Limit int32 `json:"limit"`
// Pass true to get only messages that are available without sending network requests
OnlyLocal bool `json:"only_local"`
}
// Returns messages in a chat. The messages are returned in a reverse chronological order (i.e., in order of decreasing message_id). For optimal performance, the number of returned messages is chosen by TDLib. This is an offline request if only_local is true
func (client *Client) GetChatHistory(req *GetChatHistoryRequest) (*Messages, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getChatHistory",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"from_message_id": req.FromMessageId,
"offset": req.Offset,
"limit": req.Limit,
"only_local": req.OnlyLocal,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalMessages(result.Data)
}
type GetMessageThreadHistoryRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
// Message identifier, which thread history needs to be returned
MessageId int64 `json:"message_id"`
// Identifier of the message starting from which history must be fetched; use 0 to get results from the last message
FromMessageId int64 `json:"from_message_id"`
// Specify 0 to get results from exactly the from_message_id or a negative offset up to 99 to get additionally some newer messages
Offset int32 `json:"offset"`
// The maximum number of messages to be returned; must be positive and can't be greater than 100. If the offset is negative, the limit must be greater than or equal to -offset. For optimal performance, the number of returned messages is chosen by TDLib and can be smaller than the specified limit
Limit int32 `json:"limit"`
}
// Returns messages in a message thread of a message. Can be used only if message.can_get_message_thread == true. Message thread of a channel message is in the channel's linked supergroup. The messages are returned in a reverse chronological order (i.e., in order of decreasing message_id). For optimal performance, the number of returned messages is chosen by TDLib
func (client *Client) GetMessageThreadHistory(req *GetMessageThreadHistoryRequest) (*Messages, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getMessageThreadHistory",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"message_id": req.MessageId,
"from_message_id": req.FromMessageId,
"offset": req.Offset,
"limit": req.Limit,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalMessages(result.Data)
}
type DeleteChatHistoryRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
// Pass true to remove the chat from all chat lists
RemoveFromChatList bool `json:"remove_from_chat_list"`
// Pass true to delete chat history for all users
Revoke bool `json:"revoke"`
}
// Deletes all messages in the chat. Use chat.can_be_deleted_only_for_self and chat.can_be_deleted_for_all_users fields to find whether and how the method can be applied to the chat
func (client *Client) DeleteChatHistory(req *DeleteChatHistoryRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "deleteChatHistory",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"remove_from_chat_list": req.RemoveFromChatList,
"revoke": req.Revoke,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type DeleteChatRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
}
// Deletes a chat along with all messages in the corresponding chat for all chat members. For group chats this will release the username and remove all members. Use the field chat.can_be_deleted_for_all_users to find whether the method can be applied to the chat
func (client *Client) DeleteChat(req *DeleteChatRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "deleteChat",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type SearchChatMessagesRequest struct {
// Identifier of the chat in which to search messages
ChatId int64 `json:"chat_id"`
// Query to search for
Query string `json:"query"`
// Identifier of the sender of messages to search for; pass null to search for messages from any sender. Not supported in secret chats
SenderId MessageSender `json:"sender_id"`
// Identifier of the message starting from which history must be fetched; use 0 to get results from the last message
FromMessageId int64 `json:"from_message_id"`
// Specify 0 to get results from exactly the from_message_id or a negative offset to get the specified message and some newer messages
Offset int32 `json:"offset"`
// The maximum number of messages to be returned; must be positive and can't be greater than 100. If the offset is negative, the limit must be greater than -offset. For optimal performance, the number of returned messages is chosen by TDLib and can be smaller than the specified limit
Limit int32 `json:"limit"`
// Additional filter for messages to search; pass null to search for all messages
Filter SearchMessagesFilter `json:"filter"`
// If not 0, only messages in the specified thread will be returned; supergroups only
MessageThreadId int64 `json:"message_thread_id"`
}
// Searches for messages with given words in the chat. Returns the results in reverse chronological order, i.e. in order of decreasing message_id. Cannot be used in secret chats with a non-empty query (searchSecretMessages must be used instead), or without an enabled message database. For optimal performance, the number of returned messages is chosen by TDLib and can be smaller than the specified limit
func (client *Client) SearchChatMessages(req *SearchChatMessagesRequest) (*Messages, error) {
result, err := client.Send(Request{
meta: meta{
Type: "searchChatMessages",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"query": req.Query,
"sender_id": req.SenderId,
"from_message_id": req.FromMessageId,
"offset": req.Offset,
"limit": req.Limit,
"filter": req.Filter,
"message_thread_id": req.MessageThreadId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalMessages(result.Data)
}
type SearchMessagesRequest struct {
// Chat list in which to search messages; pass null to search in all chats regardless of their chat list. Only Main and Archive chat lists are supported
ChatList ChatList `json:"chat_list"`
// Query to search for
Query string `json:"query"`
// The date of the message starting from which the results need to be fetched. Use 0 or any date in the future to get results from the last message
OffsetDate int32 `json:"offset_date"`
// The chat identifier of the last found message, or 0 for the first request
OffsetChatId int64 `json:"offset_chat_id"`
// The message identifier of the last found message, or 0 for the first request
OffsetMessageId int64 `json:"offset_message_id"`
// The maximum number of messages to be returned; up to 100. For optimal performance, the number of returned messages is chosen by TDLib and can be smaller than the specified limit
Limit int32 `json:"limit"`
// Additional filter for messages to search; pass null to search for all messages. Filters searchMessagesFilterMention, searchMessagesFilterUnreadMention, searchMessagesFilterUnreadReaction, searchMessagesFilterFailedToSend, and searchMessagesFilterPinned are unsupported in this function
Filter SearchMessagesFilter `json:"filter"`
// If not 0, the minimum date of the messages to return
MinDate int32 `json:"min_date"`
// If not 0, the maximum date of the messages to return
MaxDate int32 `json:"max_date"`
}
// Searches for messages in all chats except secret chats. Returns the results in reverse chronological order (i.e., in order of decreasing (date, chat_id, message_id)). For optimal performance, the number of returned messages is chosen by TDLib and can be smaller than the specified limit
func (client *Client) SearchMessages(req *SearchMessagesRequest) (*Messages, error) {
result, err := client.Send(Request{
meta: meta{
Type: "searchMessages",
},
Data: map[string]interface{}{
"chat_list": req.ChatList,
"query": req.Query,
"offset_date": req.OffsetDate,
"offset_chat_id": req.OffsetChatId,
"offset_message_id": req.OffsetMessageId,
"limit": req.Limit,
"filter": req.Filter,
"min_date": req.MinDate,
"max_date": req.MaxDate,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalMessages(result.Data)
}
type SearchSecretMessagesRequest struct {
// Identifier of the chat in which to search. Specify 0 to search in all secret chats
ChatId int64 `json:"chat_id"`
// Query to search for. If empty, searchChatMessages must be used instead
Query string `json:"query"`
// Offset of the first entry to return as received from the previous request; use empty string to get the first chunk of results
Offset string `json:"offset"`
// The maximum number of messages to be returned; up to 100. For optimal performance, the number of returned messages is chosen by TDLib and can be smaller than the specified limit
Limit int32 `json:"limit"`
// Additional filter for messages to search; pass null to search for all messages
Filter SearchMessagesFilter `json:"filter"`
}
// Searches for messages in secret chats. Returns the results in reverse chronological order. For optimal performance, the number of returned messages is chosen by TDLib
func (client *Client) SearchSecretMessages(req *SearchSecretMessagesRequest) (*FoundMessages, error) {
result, err := client.Send(Request{
meta: meta{
Type: "searchSecretMessages",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"query": req.Query,
"offset": req.Offset,
"limit": req.Limit,
"filter": req.Filter,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalFoundMessages(result.Data)
}
type SearchCallMessagesRequest struct {
// Identifier of the message from which to search; use 0 to get results from the last message
FromMessageId int64 `json:"from_message_id"`
// The maximum number of messages to be returned; up to 100. For optimal performance, the number of returned messages is chosen by TDLib and can be smaller than the specified limit
Limit int32 `json:"limit"`
// Pass true to search only for messages with missed/declined calls
OnlyMissed bool `json:"only_missed"`
}
// Searches for call messages. Returns the results in reverse chronological order (i. e., in order of decreasing message_id). For optimal performance, the number of returned messages is chosen by TDLib
func (client *Client) SearchCallMessages(req *SearchCallMessagesRequest) (*Messages, error) {
result, err := client.Send(Request{
meta: meta{
Type: "searchCallMessages",
},
Data: map[string]interface{}{
"from_message_id": req.FromMessageId,
"limit": req.Limit,
"only_missed": req.OnlyMissed,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalMessages(result.Data)
}
type SearchOutgoingDocumentMessagesRequest struct {
// Query to search for in document file name and message caption
Query string `json:"query"`
// The maximum number of messages to be returned; up to 100
Limit int32 `json:"limit"`
}
// Searches for outgoing messages with content of the type messageDocument in all chats except secret chats. Returns the results in reverse chronological order
func (client *Client) SearchOutgoingDocumentMessages(req *SearchOutgoingDocumentMessagesRequest) (*FoundMessages, error) {
result, err := client.Send(Request{
meta: meta{
Type: "searchOutgoingDocumentMessages",
},
Data: map[string]interface{}{
"query": req.Query,
"limit": req.Limit,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalFoundMessages(result.Data)
}
type DeleteAllCallMessagesRequest struct {
// Pass true to delete the messages for all users
Revoke bool `json:"revoke"`
}
// Deletes all call messages
func (client *Client) DeleteAllCallMessages(req *DeleteAllCallMessagesRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "deleteAllCallMessages",
},
Data: map[string]interface{}{
"revoke": req.Revoke,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type SearchChatRecentLocationMessagesRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
// The maximum number of messages to be returned
Limit int32 `json:"limit"`
}
// Returns information about the recent locations of chat members that were sent to the chat. Returns up to 1 location message per user
func (client *Client) SearchChatRecentLocationMessages(req *SearchChatRecentLocationMessagesRequest) (*Messages, error) {
result, err := client.Send(Request{
meta: meta{
Type: "searchChatRecentLocationMessages",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"limit": req.Limit,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalMessages(result.Data)
}
// Returns all active live locations that need to be updated by the application. The list is persistent across application restarts only if the message database is used
func (client *Client) GetActiveLiveLocationMessages() (*Messages, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getActiveLiveLocationMessages",
},
Data: map[string]interface{}{},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalMessages(result.Data)
}
type GetChatMessageByDateRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
// Point in time (Unix timestamp) relative to which to search for messages
Date int32 `json:"date"`
}
// Returns the last message sent in a chat no later than the specified date
func (client *Client) GetChatMessageByDate(req *GetChatMessageByDateRequest) (*Message, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getChatMessageByDate",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"date": req.Date,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalMessage(result.Data)
}
type GetChatSparseMessagePositionsRequest struct {
// Identifier of the chat in which to return information about message positions
ChatId int64 `json:"chat_id"`
// Filter for message content. Filters searchMessagesFilterEmpty, searchMessagesFilterMention, searchMessagesFilterUnreadMention, and searchMessagesFilterUnreadReaction are unsupported in this function
Filter SearchMessagesFilter `json:"filter"`
// The message identifier from which to return information about message positions
FromMessageId int64 `json:"from_message_id"`
// The expected number of message positions to be returned; 50-2000. A smaller number of positions can be returned, if there are not enough appropriate messages
Limit int32 `json:"limit"`
}
// Returns sparse positions of messages of the specified type in the chat to be used for shared media scroll implementation. Returns the results in reverse chronological order (i.e., in order of decreasing message_id). Cannot be used in secret chats or with searchMessagesFilterFailedToSend filter without an enabled message database
func (client *Client) GetChatSparseMessagePositions(req *GetChatSparseMessagePositionsRequest) (*MessagePositions, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getChatSparseMessagePositions",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"filter": req.Filter,
"from_message_id": req.FromMessageId,
"limit": req.Limit,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalMessagePositions(result.Data)
}
type GetChatMessageCalendarRequest struct {
// Identifier of the chat in which to return information about messages
ChatId int64 `json:"chat_id"`
// Filter for message content. Filters searchMessagesFilterEmpty, searchMessagesFilterMention, searchMessagesFilterUnreadMention, and searchMessagesFilterUnreadReaction are unsupported in this function
Filter SearchMessagesFilter `json:"filter"`
// The message identifier from which to return information about messages; use 0 to get results from the last message
FromMessageId int64 `json:"from_message_id"`
}
// Returns information about the next messages of the specified type in the chat split by days. Returns the results in reverse chronological order. Can return partial result for the last returned day. Behavior of this method depends on the value of the option "utc_time_offset"
func (client *Client) GetChatMessageCalendar(req *GetChatMessageCalendarRequest) (*MessageCalendar, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getChatMessageCalendar",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"filter": req.Filter,
"from_message_id": req.FromMessageId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalMessageCalendar(result.Data)
}
type GetChatMessageCountRequest struct {
// Identifier of the chat in which to count messages
ChatId int64 `json:"chat_id"`
// Filter for message content; searchMessagesFilterEmpty is unsupported in this function
Filter SearchMessagesFilter `json:"filter"`
// Pass true to get the number of messages without sending network requests, or -1 if the number of messages is unknown locally
ReturnLocal bool `json:"return_local"`
}
// Returns approximate number of messages of the specified type in the chat
func (client *Client) GetChatMessageCount(req *GetChatMessageCountRequest) (*Count, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getChatMessageCount",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"filter": req.Filter,
"return_local": req.ReturnLocal,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalCount(result.Data)
}
type GetChatScheduledMessagesRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
}
// Returns all scheduled messages in a chat. The messages are returned in a reverse chronological order (i.e., in order of decreasing message_id)
func (client *Client) GetChatScheduledMessages(req *GetChatScheduledMessagesRequest) (*Messages, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getChatScheduledMessages",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalMessages(result.Data)
}
type GetMessagePublicForwardsRequest struct {
// Chat identifier of the message
ChatId int64 `json:"chat_id"`
// Message identifier
MessageId int64 `json:"message_id"`
// Offset of the first entry to return as received from the previous request; use empty string to get the first chunk of results
Offset string `json:"offset"`
// The maximum number of messages to be returned; must be positive and can't be greater than 100. For optimal performance, the number of returned messages is chosen by TDLib and can be smaller than the specified limit
Limit int32 `json:"limit"`
}
// Returns forwarded copies of a channel message to different public channels. For optimal performance, the number of returned messages is chosen by TDLib
func (client *Client) GetMessagePublicForwards(req *GetMessagePublicForwardsRequest) (*FoundMessages, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getMessagePublicForwards",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"message_id": req.MessageId,
"offset": req.Offset,
"limit": req.Limit,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalFoundMessages(result.Data)
}
type GetChatSponsoredMessageRequest struct {
// Identifier of the chat
ChatId int64 `json:"chat_id"`
}
// Returns sponsored message to be shown in a chat; for channel chats only. Returns a 404 error if there is no sponsored message in the chat
func (client *Client) GetChatSponsoredMessage(req *GetChatSponsoredMessageRequest) (*SponsoredMessage, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getChatSponsoredMessage",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalSponsoredMessage(result.Data)
}
type RemoveNotificationRequest struct {
// Identifier of notification group to which the notification belongs
NotificationGroupId int32 `json:"notification_group_id"`
// Identifier of removed notification
NotificationId int32 `json:"notification_id"`
}
// Removes an active notification from notification list. Needs to be called only if the notification is removed by the current user
func (client *Client) RemoveNotification(req *RemoveNotificationRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "removeNotification",
},
Data: map[string]interface{}{
"notification_group_id": req.NotificationGroupId,
"notification_id": req.NotificationId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type RemoveNotificationGroupRequest struct {
// Notification group identifier
NotificationGroupId int32 `json:"notification_group_id"`
// The maximum identifier of removed notifications
MaxNotificationId int32 `json:"max_notification_id"`
}
// Removes a group of active notifications. Needs to be called only if the notification group is removed by the current user
func (client *Client) RemoveNotificationGroup(req *RemoveNotificationGroupRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "removeNotificationGroup",
},
Data: map[string]interface{}{
"notification_group_id": req.NotificationGroupId,
"max_notification_id": req.MaxNotificationId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type GetMessageLinkRequest struct {
// Identifier of the chat to which the message belongs
ChatId int64 `json:"chat_id"`
// Identifier of the message
MessageId int64 `json:"message_id"`
// If not 0, timestamp from which the video/audio/video note/voice note playing must start, in seconds. The media can be in the message content or in its web page preview
MediaTimestamp int32 `json:"media_timestamp"`
// Pass true to create a link for the whole media album
ForAlbum bool `json:"for_album"`
// Pass true to create a link to the message as a channel post comment, or from a message thread
ForComment bool `json:"for_comment"`
}
// Returns an HTTPS link to a message in a chat. Available only for already sent messages in supergroups and channels, or if message.can_get_media_timestamp_links and a media timestamp link is generated. This is an offline request
func (client *Client) GetMessageLink(req *GetMessageLinkRequest) (*MessageLink, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getMessageLink",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"message_id": req.MessageId,
"media_timestamp": req.MediaTimestamp,
"for_album": req.ForAlbum,
"for_comment": req.ForComment,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalMessageLink(result.Data)
}
type GetMessageEmbeddingCodeRequest struct {
// Identifier of the chat to which the message belongs
ChatId int64 `json:"chat_id"`
// Identifier of the message
MessageId int64 `json:"message_id"`
// Pass true to return an HTML code for embedding of the whole media album
ForAlbum bool `json:"for_album"`
}
// Returns an HTML code for embedding the message. Available only for messages in supergroups and channels with a username
func (client *Client) GetMessageEmbeddingCode(req *GetMessageEmbeddingCodeRequest) (*Text, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getMessageEmbeddingCode",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"message_id": req.MessageId,
"for_album": req.ForAlbum,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalText(result.Data)
}
type GetMessageLinkInfoRequest struct {
// The message link
Url string `json:"url"`
}
// Returns information about a public or private message link. Can be called for any internal link of the type internalLinkTypeMessage
func (client *Client) GetMessageLinkInfo(req *GetMessageLinkInfoRequest) (*MessageLinkInfo, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getMessageLinkInfo",
},
Data: map[string]interface{}{
"url": req.Url,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalMessageLinkInfo(result.Data)
}
type TranslateTextRequest struct {
// Text to translate
Text string `json:"text"`
// A two-letter ISO 639-1 language code of the language from which the message is translated. If empty, the language will be detected automatically
FromLanguageCode string `json:"from_language_code"`
// A two-letter ISO 639-1 language code of the language to which the message is translated
ToLanguageCode string `json:"to_language_code"`
}
// Translates a text to the given language. Returns a 404 error if the translation can't be performed
func (client *Client) TranslateText(req *TranslateTextRequest) (*Text, error) {
result, err := client.Send(Request{
meta: meta{
Type: "translateText",
},
Data: map[string]interface{}{
"text": req.Text,
"from_language_code": req.FromLanguageCode,
"to_language_code": req.ToLanguageCode,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalText(result.Data)
}
type GetChatAvailableMessageSendersRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
}
// Returns list of message sender identifiers, which can be used to send messages in a chat
func (client *Client) GetChatAvailableMessageSenders(req *GetChatAvailableMessageSendersRequest) (*MessageSenders, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getChatAvailableMessageSenders",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalMessageSenders(result.Data)
}
type SetChatMessageSenderRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
// New message sender for the chat
MessageSenderId MessageSender `json:"message_sender_id"`
}
// Selects a message sender to send messages in a chat
func (client *Client) SetChatMessageSender(req *SetChatMessageSenderRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "setChatMessageSender",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"message_sender_id": req.MessageSenderId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type SendMessageRequest struct {
// Target chat
ChatId int64 `json:"chat_id"`
// If not 0, a message thread identifier in which the message will be sent
MessageThreadId int64 `json:"message_thread_id"`
// Identifier of the replied message; 0 if none
ReplyToMessageId int64 `json:"reply_to_message_id"`
// Options to be used to send the message; pass null to use default options
Options *MessageSendOptions `json:"options"`
// Markup for replying to the message; pass null if none; for bots only
ReplyMarkup ReplyMarkup `json:"reply_markup"`
// The content of the message to be sent
InputMessageContent InputMessageContent `json:"input_message_content"`
}
// Sends a message. Returns the sent message
func (client *Client) SendMessage(req *SendMessageRequest) (*Message, error) {
result, err := client.Send(Request{
meta: meta{
Type: "sendMessage",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"message_thread_id": req.MessageThreadId,
"reply_to_message_id": req.ReplyToMessageId,
"options": req.Options,
"reply_markup": req.ReplyMarkup,
"input_message_content": req.InputMessageContent,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalMessage(result.Data)
}
type SendMessageAlbumRequest struct {
// Target chat
ChatId int64 `json:"chat_id"`
// If not 0, a message thread identifier in which the messages will be sent
MessageThreadId int64 `json:"message_thread_id"`
// Identifier of a replied message; 0 if none
ReplyToMessageId int64 `json:"reply_to_message_id"`
// Options to be used to send the messages; pass null to use default options
Options *MessageSendOptions `json:"options"`
// Contents of messages to be sent. At most 10 messages can be added to an album
InputMessageContents []InputMessageContent `json:"input_message_contents"`
// Pass true to get fake messages instead of actually sending them
OnlyPreview bool `json:"only_preview"`
}
// Sends 2-10 messages grouped together into an album. Currently, only audio, document, photo and video messages can be grouped into an album. Documents and audio files can be only grouped in an album with messages of the same type. Returns sent messages
func (client *Client) SendMessageAlbum(req *SendMessageAlbumRequest) (*Messages, error) {
result, err := client.Send(Request{
meta: meta{
Type: "sendMessageAlbum",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"message_thread_id": req.MessageThreadId,
"reply_to_message_id": req.ReplyToMessageId,
"options": req.Options,
"input_message_contents": req.InputMessageContents,
"only_preview": req.OnlyPreview,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalMessages(result.Data)
}
type SendBotStartMessageRequest struct {
// Identifier of the bot
BotUserId int64 `json:"bot_user_id"`
// Identifier of the target chat
ChatId int64 `json:"chat_id"`
// A hidden parameter sent to the bot for deep linking purposes (https://core.telegram.org/bots#deep-linking)
Parameter string `json:"parameter"`
}
// Invites a bot to a chat (if it is not yet a member) and sends it the /start command. Bots can't be invited to a private chat other than the chat with the bot. Bots can't be invited to channels (although they can be added as admins) and secret chats. Returns the sent message
func (client *Client) SendBotStartMessage(req *SendBotStartMessageRequest) (*Message, error) {
result, err := client.Send(Request{
meta: meta{
Type: "sendBotStartMessage",
},
Data: map[string]interface{}{
"bot_user_id": req.BotUserId,
"chat_id": req.ChatId,
"parameter": req.Parameter,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalMessage(result.Data)
}
type SendInlineQueryResultMessageRequest struct {
// Target chat
ChatId int64 `json:"chat_id"`
// If not 0, a message thread identifier in which the message will be sent
MessageThreadId int64 `json:"message_thread_id"`
// Identifier of a replied message; 0 if none
ReplyToMessageId int64 `json:"reply_to_message_id"`
// Options to be used to send the message; pass null to use default options
Options *MessageSendOptions `json:"options"`
// Identifier of the inline query
QueryId JsonInt64 `json:"query_id"`
// Identifier of the inline result
ResultId string `json:"result_id"`
// Pass true to hide the bot, via which the message is sent. Can be used only for bots GetOption("animation_search_bot_username"), GetOption("photo_search_bot_username"), and GetOption("venue_search_bot_username")
HideViaBot bool `json:"hide_via_bot"`
}
// Sends the result of an inline query as a message. Returns the sent message. Always clears a chat draft message
func (client *Client) SendInlineQueryResultMessage(req *SendInlineQueryResultMessageRequest) (*Message, error) {
result, err := client.Send(Request{
meta: meta{
Type: "sendInlineQueryResultMessage",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"message_thread_id": req.MessageThreadId,
"reply_to_message_id": req.ReplyToMessageId,
"options": req.Options,
"query_id": req.QueryId,
"result_id": req.ResultId,
"hide_via_bot": req.HideViaBot,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalMessage(result.Data)
}
type ForwardMessagesRequest struct {
// Identifier of the chat to which to forward messages
ChatId int64 `json:"chat_id"`
// Identifier of the chat from which to forward messages
FromChatId int64 `json:"from_chat_id"`
// Identifiers of the messages to forward. Message identifiers must be in a strictly increasing order. At most 100 messages can be forwarded simultaneously
MessageIds []int64 `json:"message_ids"`
// Options to be used to send the messages; pass null to use default options
Options *MessageSendOptions `json:"options"`
// Pass true to copy content of the messages without reference to the original sender. Always true if the messages are forwarded to a secret chat or are local
SendCopy bool `json:"send_copy"`
// Pass true to remove media captions of message copies. Ignored if send_copy is false
RemoveCaption bool `json:"remove_caption"`
// Pass true to get fake messages instead of actually forwarding them
OnlyPreview bool `json:"only_preview"`
}
// Forwards previously sent messages. Returns the forwarded messages in the same order as the message identifiers passed in message_ids. If a message can't be forwarded, null will be returned instead of the message
func (client *Client) ForwardMessages(req *ForwardMessagesRequest) (*Messages, error) {
result, err := client.Send(Request{
meta: meta{
Type: "forwardMessages",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"from_chat_id": req.FromChatId,
"message_ids": req.MessageIds,
"options": req.Options,
"send_copy": req.SendCopy,
"remove_caption": req.RemoveCaption,
"only_preview": req.OnlyPreview,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalMessages(result.Data)
}
type ResendMessagesRequest struct {
// Identifier of the chat to send messages
ChatId int64 `json:"chat_id"`
// Identifiers of the messages to resend. Message identifiers must be in a strictly increasing order
MessageIds []int64 `json:"message_ids"`
}
// Resends messages which failed to send. Can be called only for messages for which messageSendingStateFailed.can_retry is true and after specified in messageSendingStateFailed.retry_after time passed. If a message is re-sent, the corresponding failed to send message is deleted. Returns the sent messages in the same order as the message identifiers passed in message_ids. If a message can't be re-sent, null will be returned instead of the message
func (client *Client) ResendMessages(req *ResendMessagesRequest) (*Messages, error) {
result, err := client.Send(Request{
meta: meta{
Type: "resendMessages",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"message_ids": req.MessageIds,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalMessages(result.Data)
}
type SendChatScreenshotTakenNotificationRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
}
// Sends a notification about a screenshot taken in a chat. Supported only in private and secret chats
func (client *Client) SendChatScreenshotTakenNotification(req *SendChatScreenshotTakenNotificationRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "sendChatScreenshotTakenNotification",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type AddLocalMessageRequest struct {
// Target chat
ChatId int64 `json:"chat_id"`
// Identifier of the sender of the message
SenderId MessageSender `json:"sender_id"`
// Identifier of the replied message; 0 if none
ReplyToMessageId int64 `json:"reply_to_message_id"`
// Pass true to disable notification for the message
DisableNotification bool `json:"disable_notification"`
// The content of the message to be added
InputMessageContent InputMessageContent `json:"input_message_content"`
}
// Adds a local message to a chat. The message is persistent across application restarts only if the message database is used. Returns the added message
func (client *Client) AddLocalMessage(req *AddLocalMessageRequest) (*Message, error) {
result, err := client.Send(Request{
meta: meta{
Type: "addLocalMessage",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"sender_id": req.SenderId,
"reply_to_message_id": req.ReplyToMessageId,
"disable_notification": req.DisableNotification,
"input_message_content": req.InputMessageContent,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalMessage(result.Data)
}
type DeleteMessagesRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
// Identifiers of the messages to be deleted
MessageIds []int64 `json:"message_ids"`
// Pass true to delete messages for all chat members. Always true for supergroups, channels and secret chats
Revoke bool `json:"revoke"`
}
// Deletes messages
func (client *Client) DeleteMessages(req *DeleteMessagesRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "deleteMessages",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"message_ids": req.MessageIds,
"revoke": req.Revoke,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type DeleteChatMessagesBySenderRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
// Identifier of the sender of messages to delete
SenderId MessageSender `json:"sender_id"`
}
// Deletes all messages sent by the specified message sender in a chat. Supported only for supergroups; requires can_delete_messages administrator privileges
func (client *Client) DeleteChatMessagesBySender(req *DeleteChatMessagesBySenderRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "deleteChatMessagesBySender",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"sender_id": req.SenderId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type DeleteChatMessagesByDateRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
// The minimum date of the messages to delete
MinDate int32 `json:"min_date"`
// The maximum date of the messages to delete
MaxDate int32 `json:"max_date"`
// Pass true to delete chat messages for all users; private chats only
Revoke bool `json:"revoke"`
}
// Deletes all messages between the specified dates in a chat. Supported only for private chats and basic groups. Messages sent in the last 30 seconds will not be deleted
func (client *Client) DeleteChatMessagesByDate(req *DeleteChatMessagesByDateRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "deleteChatMessagesByDate",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"min_date": req.MinDate,
"max_date": req.MaxDate,
"revoke": req.Revoke,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type EditMessageTextRequest struct {
// The chat the message belongs to
ChatId int64 `json:"chat_id"`
// Identifier of the message
MessageId int64 `json:"message_id"`
// The new message reply markup; pass null if none; for bots only
ReplyMarkup ReplyMarkup `json:"reply_markup"`
// New text content of the message. Must be of type inputMessageText
InputMessageContent InputMessageContent `json:"input_message_content"`
}
// Edits the text of a message (or a text of a game message). Returns the edited message after the edit is completed on the server side
func (client *Client) EditMessageText(req *EditMessageTextRequest) (*Message, error) {
result, err := client.Send(Request{
meta: meta{
Type: "editMessageText",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"message_id": req.MessageId,
"reply_markup": req.ReplyMarkup,
"input_message_content": req.InputMessageContent,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalMessage(result.Data)
}
type EditMessageLiveLocationRequest struct {
// The chat the message belongs to
ChatId int64 `json:"chat_id"`
// Identifier of the message
MessageId int64 `json:"message_id"`
// The new message reply markup; pass null if none; for bots only
ReplyMarkup ReplyMarkup `json:"reply_markup"`
// New location content of the message; pass null to stop sharing the live location
Location *Location `json:"location"`
// The new direction in which the location moves, in degrees; 1-360. Pass 0 if unknown
Heading int32 `json:"heading"`
// The new maximum distance for proximity alerts, in meters (0-100000). Pass 0 if the notification is disabled
ProximityAlertRadius int32 `json:"proximity_alert_radius"`
}
// Edits the message content of a live location. Messages can be edited for a limited period of time specified in the live location. Returns the edited message after the edit is completed on the server side
func (client *Client) EditMessageLiveLocation(req *EditMessageLiveLocationRequest) (*Message, error) {
result, err := client.Send(Request{
meta: meta{
Type: "editMessageLiveLocation",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"message_id": req.MessageId,
"reply_markup": req.ReplyMarkup,
"location": req.Location,
"heading": req.Heading,
"proximity_alert_radius": req.ProximityAlertRadius,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalMessage(result.Data)
}
type EditMessageMediaRequest struct {
// The chat the message belongs to
ChatId int64 `json:"chat_id"`
// Identifier of the message
MessageId int64 `json:"message_id"`
// The new message reply markup; pass null if none; for bots only
ReplyMarkup ReplyMarkup `json:"reply_markup"`
// New content of the message. Must be one of the following types: inputMessageAnimation, inputMessageAudio, inputMessageDocument, inputMessagePhoto or inputMessageVideo
InputMessageContent InputMessageContent `json:"input_message_content"`
}
// Edits the content of a message with an animation, an audio, a document, a photo or a video, including message caption. If only the caption needs to be edited, use editMessageCaption instead. The media can't be edited if the message was set to self-destruct or to a self-destructing media. The type of message content in an album can't be changed with exception of replacing a photo with a video or vice versa. Returns the edited message after the edit is completed on the server side
func (client *Client) EditMessageMedia(req *EditMessageMediaRequest) (*Message, error) {
result, err := client.Send(Request{
meta: meta{
Type: "editMessageMedia",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"message_id": req.MessageId,
"reply_markup": req.ReplyMarkup,
"input_message_content": req.InputMessageContent,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalMessage(result.Data)
}
type EditMessageCaptionRequest struct {
// The chat the message belongs to
ChatId int64 `json:"chat_id"`
// Identifier of the message
MessageId int64 `json:"message_id"`
// The new message reply markup; pass null if none; for bots only
ReplyMarkup ReplyMarkup `json:"reply_markup"`
// New message content caption; 0-GetOption("message_caption_length_max") characters; pass null to remove caption
Caption *FormattedText `json:"caption"`
}
// Edits the message content caption. Returns the edited message after the edit is completed on the server side
func (client *Client) EditMessageCaption(req *EditMessageCaptionRequest) (*Message, error) {
result, err := client.Send(Request{
meta: meta{
Type: "editMessageCaption",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"message_id": req.MessageId,
"reply_markup": req.ReplyMarkup,
"caption": req.Caption,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalMessage(result.Data)
}
type EditMessageReplyMarkupRequest struct {
// The chat the message belongs to
ChatId int64 `json:"chat_id"`
// Identifier of the message
MessageId int64 `json:"message_id"`
// The new message reply markup; pass null if none
ReplyMarkup ReplyMarkup `json:"reply_markup"`
}
// Edits the message reply markup; for bots only. Returns the edited message after the edit is completed on the server side
func (client *Client) EditMessageReplyMarkup(req *EditMessageReplyMarkupRequest) (*Message, error) {
result, err := client.Send(Request{
meta: meta{
Type: "editMessageReplyMarkup",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"message_id": req.MessageId,
"reply_markup": req.ReplyMarkup,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalMessage(result.Data)
}
type EditInlineMessageTextRequest struct {
// Inline message identifier
InlineMessageId string `json:"inline_message_id"`
// The new message reply markup; pass null if none
ReplyMarkup ReplyMarkup `json:"reply_markup"`
// New text content of the message. Must be of type inputMessageText
InputMessageContent InputMessageContent `json:"input_message_content"`
}
// Edits the text of an inline text or game message sent via a bot; for bots only
func (client *Client) EditInlineMessageText(req *EditInlineMessageTextRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "editInlineMessageText",
},
Data: map[string]interface{}{
"inline_message_id": req.InlineMessageId,
"reply_markup": req.ReplyMarkup,
"input_message_content": req.InputMessageContent,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type EditInlineMessageLiveLocationRequest struct {
// Inline message identifier
InlineMessageId string `json:"inline_message_id"`
// The new message reply markup; pass null if none
ReplyMarkup ReplyMarkup `json:"reply_markup"`
// New location content of the message; pass null to stop sharing the live location
Location *Location `json:"location"`
// The new direction in which the location moves, in degrees; 1-360. Pass 0 if unknown
Heading int32 `json:"heading"`
// The new maximum distance for proximity alerts, in meters (0-100000). Pass 0 if the notification is disabled
ProximityAlertRadius int32 `json:"proximity_alert_radius"`
}
// Edits the content of a live location in an inline message sent via a bot; for bots only
func (client *Client) EditInlineMessageLiveLocation(req *EditInlineMessageLiveLocationRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "editInlineMessageLiveLocation",
},
Data: map[string]interface{}{
"inline_message_id": req.InlineMessageId,
"reply_markup": req.ReplyMarkup,
"location": req.Location,
"heading": req.Heading,
"proximity_alert_radius": req.ProximityAlertRadius,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type EditInlineMessageMediaRequest struct {
// Inline message identifier
InlineMessageId string `json:"inline_message_id"`
// The new message reply markup; pass null if none; for bots only
ReplyMarkup ReplyMarkup `json:"reply_markup"`
// New content of the message. Must be one of the following types: inputMessageAnimation, inputMessageAudio, inputMessageDocument, inputMessagePhoto or inputMessageVideo
InputMessageContent InputMessageContent `json:"input_message_content"`
}
// Edits the content of a message with an animation, an audio, a document, a photo or a video in an inline message sent via a bot; for bots only
func (client *Client) EditInlineMessageMedia(req *EditInlineMessageMediaRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "editInlineMessageMedia",
},
Data: map[string]interface{}{
"inline_message_id": req.InlineMessageId,
"reply_markup": req.ReplyMarkup,
"input_message_content": req.InputMessageContent,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type EditInlineMessageCaptionRequest struct {
// Inline message identifier
InlineMessageId string `json:"inline_message_id"`
// The new message reply markup; pass null if none
ReplyMarkup ReplyMarkup `json:"reply_markup"`
// New message content caption; pass null to remove caption; 0-GetOption("message_caption_length_max") characters
Caption *FormattedText `json:"caption"`
}
// Edits the caption of an inline message sent via a bot; for bots only
func (client *Client) EditInlineMessageCaption(req *EditInlineMessageCaptionRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "editInlineMessageCaption",
},
Data: map[string]interface{}{
"inline_message_id": req.InlineMessageId,
"reply_markup": req.ReplyMarkup,
"caption": req.Caption,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type EditInlineMessageReplyMarkupRequest struct {
// Inline message identifier
InlineMessageId string `json:"inline_message_id"`
// The new message reply markup; pass null if none
ReplyMarkup ReplyMarkup `json:"reply_markup"`
}
// Edits the reply markup of an inline message sent via a bot; for bots only
func (client *Client) EditInlineMessageReplyMarkup(req *EditInlineMessageReplyMarkupRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "editInlineMessageReplyMarkup",
},
Data: map[string]interface{}{
"inline_message_id": req.InlineMessageId,
"reply_markup": req.ReplyMarkup,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type EditMessageSchedulingStateRequest struct {
// The chat the message belongs to
ChatId int64 `json:"chat_id"`
// Identifier of the message
MessageId int64 `json:"message_id"`
// The new message scheduling state; pass null to send the message immediately
SchedulingState MessageSchedulingState `json:"scheduling_state"`
}
// Edits the time when a scheduled message will be sent. Scheduling state of all messages in the same album or forwarded together with the message will be also changed
func (client *Client) EditMessageSchedulingState(req *EditMessageSchedulingStateRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "editMessageSchedulingState",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"message_id": req.MessageId,
"scheduling_state": req.SchedulingState,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type GetMessageAvailableReactionsRequest struct {
// Identifier of the chat to which the message belongs
ChatId int64 `json:"chat_id"`
// Identifier of the message
MessageId int64 `json:"message_id"`
}
// Returns reactions, which can be added to a message. The list can change after updateReactions, updateChatAvailableReactions for the chat, or updateMessageInteractionInfo for the message
func (client *Client) GetMessageAvailableReactions(req *GetMessageAvailableReactionsRequest) (*AvailableReactions, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getMessageAvailableReactions",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"message_id": req.MessageId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalAvailableReactions(result.Data)
}
type SetMessageReactionRequest struct {
// Identifier of the chat to which the message belongs
ChatId int64 `json:"chat_id"`
// Identifier of the message
MessageId int64 `json:"message_id"`
// Text representation of the new chosen reaction. Can be an empty string or the currently chosen non-big reaction to remove the reaction
Reaction string `json:"reaction"`
// Pass true if the reaction is added with a big animation
IsBig bool `json:"is_big"`
}
// Changes chosen reaction for a message
func (client *Client) SetMessageReaction(req *SetMessageReactionRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "setMessageReaction",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"message_id": req.MessageId,
"reaction": req.Reaction,
"is_big": req.IsBig,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type GetMessageAddedReactionsRequest struct {
// Identifier of the chat to which the message belongs
ChatId int64 `json:"chat_id"`
// Identifier of the message
MessageId int64 `json:"message_id"`
// If non-empty, only added reactions with the specified text representation will be returned
Reaction string `json:"reaction"`
// Offset of the first entry to return as received from the previous request; use empty string to get the first chunk of results
Offset string `json:"offset"`
// The maximum number of reactions to be returned; must be positive and can't be greater than 100
Limit int32 `json:"limit"`
}
// Returns reactions added for a message, along with their sender
func (client *Client) GetMessageAddedReactions(req *GetMessageAddedReactionsRequest) (*AddedReactions, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getMessageAddedReactions",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"message_id": req.MessageId,
"reaction": req.Reaction,
"offset": req.Offset,
"limit": req.Limit,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalAddedReactions(result.Data)
}
type GetTextEntitiesRequest struct {
// The text in which to look for entites
Text string `json:"text"`
}
// Returns all entities (mentions, hashtags, cashtags, bot commands, bank card numbers, URLs, and email addresses) contained in the text. Can be called synchronously
func GetTextEntities(req *GetTextEntitiesRequest) (*TextEntities, error) {
result, err := Execute(Request{
meta: meta{
Type: "getTextEntities",
},
Data: map[string]interface{}{
"text": req.Text,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalTextEntities(result.Data)
}
// deprecated
// Returns all entities (mentions, hashtags, cashtags, bot commands, bank card numbers, URLs, and email addresses) contained in the text. Can be called synchronously
func (client *Client) GetTextEntities(req *GetTextEntitiesRequest) (*TextEntities, error) {
return GetTextEntities(req)}
type ParseTextEntitiesRequest struct {
// The text to parse
Text string `json:"text"`
// Text parse mode
ParseMode TextParseMode `json:"parse_mode"`
}
// Parses Bold, Italic, Underline, Strikethrough, Spoiler, Code, Pre, PreCode, TextUrl and MentionName entities contained in the text. Can be called synchronously
func ParseTextEntities(req *ParseTextEntitiesRequest) (*FormattedText, error) {
result, err := Execute(Request{
meta: meta{
Type: "parseTextEntities",
},
Data: map[string]interface{}{
"text": req.Text,
"parse_mode": req.ParseMode,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalFormattedText(result.Data)
}
// deprecated
// Parses Bold, Italic, Underline, Strikethrough, Spoiler, Code, Pre, PreCode, TextUrl and MentionName entities contained in the text. Can be called synchronously
func (client *Client) ParseTextEntities(req *ParseTextEntitiesRequest) (*FormattedText, error) {
return ParseTextEntities(req)}
type ParseMarkdownRequest struct {
// The text to parse. For example, "__italic__ ~~strikethrough~~ ||spoiler|| **bold** `code` ```pre``` __[italic__ text_url](telegram.org) __italic**bold italic__bold**"
Text *FormattedText `json:"text"`
}
// Parses Markdown entities in a human-friendly format, ignoring markup errors. Can be called synchronously
func ParseMarkdown(req *ParseMarkdownRequest) (*FormattedText, error) {
result, err := Execute(Request{
meta: meta{
Type: "parseMarkdown",
},
Data: map[string]interface{}{
"text": req.Text,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalFormattedText(result.Data)
}
// deprecated
// Parses Markdown entities in a human-friendly format, ignoring markup errors. Can be called synchronously
func (client *Client) ParseMarkdown(req *ParseMarkdownRequest) (*FormattedText, error) {
return ParseMarkdown(req)}
type GetMarkdownTextRequest struct {
// The text
Text *FormattedText `json:"text"`
}
// Replaces text entities with Markdown formatting in a human-friendly format. Entities that can't be represented in Markdown unambiguously are kept as is. Can be called synchronously
func GetMarkdownText(req *GetMarkdownTextRequest) (*FormattedText, error) {
result, err := Execute(Request{
meta: meta{
Type: "getMarkdownText",
},
Data: map[string]interface{}{
"text": req.Text,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalFormattedText(result.Data)
}
// deprecated
// Replaces text entities with Markdown formatting in a human-friendly format. Entities that can't be represented in Markdown unambiguously are kept as is. Can be called synchronously
func (client *Client) GetMarkdownText(req *GetMarkdownTextRequest) (*FormattedText, error) {
return GetMarkdownText(req)}
type GetFileMimeTypeRequest struct {
// The name of the file or path to the file
FileName string `json:"file_name"`
}
// Returns the MIME type of a file, guessed by its extension. Returns an empty string on failure. Can be called synchronously
func GetFileMimeType(req *GetFileMimeTypeRequest) (*Text, error) {
result, err := Execute(Request{
meta: meta{
Type: "getFileMimeType",
},
Data: map[string]interface{}{
"file_name": req.FileName,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalText(result.Data)
}
// deprecated
// Returns the MIME type of a file, guessed by its extension. Returns an empty string on failure. Can be called synchronously
func (client *Client) GetFileMimeType(req *GetFileMimeTypeRequest) (*Text, error) {
return GetFileMimeType(req)}
type GetFileExtensionRequest struct {
// The MIME type of the file
MimeType string `json:"mime_type"`
}
// Returns the extension of a file, guessed by its MIME type. Returns an empty string on failure. Can be called synchronously
func GetFileExtension(req *GetFileExtensionRequest) (*Text, error) {
result, err := Execute(Request{
meta: meta{
Type: "getFileExtension",
},
Data: map[string]interface{}{
"mime_type": req.MimeType,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalText(result.Data)
}
// deprecated
// Returns the extension of a file, guessed by its MIME type. Returns an empty string on failure. Can be called synchronously
func (client *Client) GetFileExtension(req *GetFileExtensionRequest) (*Text, error) {
return GetFileExtension(req)}
type CleanFileNameRequest struct {
// File name or path to the file
FileName string `json:"file_name"`
}
// Removes potentially dangerous characters from the name of a file. The encoding of the file name is supposed to be UTF-8. Returns an empty string on failure. Can be called synchronously
func CleanFileName(req *CleanFileNameRequest) (*Text, error) {
result, err := Execute(Request{
meta: meta{
Type: "cleanFileName",
},
Data: map[string]interface{}{
"file_name": req.FileName,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalText(result.Data)
}
// deprecated
// Removes potentially dangerous characters from the name of a file. The encoding of the file name is supposed to be UTF-8. Returns an empty string on failure. Can be called synchronously
func (client *Client) CleanFileName(req *CleanFileNameRequest) (*Text, error) {
return CleanFileName(req)}
type GetLanguagePackStringRequest struct {
// Path to the language pack database in which strings are stored
LanguagePackDatabasePath string `json:"language_pack_database_path"`
// Localization target to which the language pack belongs
LocalizationTarget string `json:"localization_target"`
// Language pack identifier
LanguagePackId string `json:"language_pack_id"`
// Language pack key of the string to be returned
Key string `json:"key"`
}
// Returns a string stored in the local database from the specified localization target and language pack by its key. Returns a 404 error if the string is not found. Can be called synchronously
func GetLanguagePackString(req *GetLanguagePackStringRequest) (LanguagePackStringValue, error) {
result, err := Execute(Request{
meta: meta{
Type: "getLanguagePackString",
},
Data: map[string]interface{}{
"language_pack_database_path": req.LanguagePackDatabasePath,
"localization_target": req.LocalizationTarget,
"language_pack_id": req.LanguagePackId,
"key": req.Key,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
switch result.Type {
case TypeLanguagePackStringValueOrdinary:
return UnmarshalLanguagePackStringValueOrdinary(result.Data)
case TypeLanguagePackStringValuePluralized:
return UnmarshalLanguagePackStringValuePluralized(result.Data)
case TypeLanguagePackStringValueDeleted:
return UnmarshalLanguagePackStringValueDeleted(result.Data)
default:
return nil, errors.New("invalid type")
}
}
// deprecated
// Returns a string stored in the local database from the specified localization target and language pack by its key. Returns a 404 error if the string is not found. Can be called synchronously
func (client *Client) GetLanguagePackString(req *GetLanguagePackStringRequest) (LanguagePackStringValue, error) {
return GetLanguagePackString(req)}
type GetJsonValueRequest struct {
// The JSON-serialized string
Json string `json:"json"`
}
// Converts a JSON-serialized string to corresponding JsonValue object. Can be called synchronously
func GetJsonValue(req *GetJsonValueRequest) (JsonValue, error) {
result, err := Execute(Request{
meta: meta{
Type: "getJsonValue",
},
Data: map[string]interface{}{
"json": req.Json,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
switch result.Type {
case TypeJsonValueNull:
return UnmarshalJsonValueNull(result.Data)
case TypeJsonValueBoolean:
return UnmarshalJsonValueBoolean(result.Data)
case TypeJsonValueNumber:
return UnmarshalJsonValueNumber(result.Data)
case TypeJsonValueString:
return UnmarshalJsonValueString(result.Data)
case TypeJsonValueArray:
return UnmarshalJsonValueArray(result.Data)
case TypeJsonValueObject:
return UnmarshalJsonValueObject(result.Data)
default:
return nil, errors.New("invalid type")
}
}
// deprecated
// Converts a JSON-serialized string to corresponding JsonValue object. Can be called synchronously
func (client *Client) GetJsonValue(req *GetJsonValueRequest) (JsonValue, error) {
return GetJsonValue(req)}
type GetJsonStringRequest struct {
// The JsonValue object
JsonValue JsonValue `json:"json_value"`
}
// Converts a JsonValue object to corresponding JSON-serialized string. Can be called synchronously
func GetJsonString(req *GetJsonStringRequest) (*Text, error) {
result, err := Execute(Request{
meta: meta{
Type: "getJsonString",
},
Data: map[string]interface{}{
"json_value": req.JsonValue,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalText(result.Data)
}
// deprecated
// Converts a JsonValue object to corresponding JSON-serialized string. Can be called synchronously
func (client *Client) GetJsonString(req *GetJsonStringRequest) (*Text, error) {
return GetJsonString(req)}
type GetThemeParametersJsonStringRequest struct {
// Theme parameters to convert to JSON
Theme *ThemeParameters `json:"theme"`
}
// Converts a themeParameters object to corresponding JSON-serialized string. Can be called synchronously
func GetThemeParametersJsonString(req *GetThemeParametersJsonStringRequest) (*Text, error) {
result, err := Execute(Request{
meta: meta{
Type: "getThemeParametersJsonString",
},
Data: map[string]interface{}{
"theme": req.Theme,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalText(result.Data)
}
// deprecated
// Converts a themeParameters object to corresponding JSON-serialized string. Can be called synchronously
func (client *Client) GetThemeParametersJsonString(req *GetThemeParametersJsonStringRequest) (*Text, error) {
return GetThemeParametersJsonString(req)}
type SetPollAnswerRequest struct {
// Identifier of the chat to which the poll belongs
ChatId int64 `json:"chat_id"`
// Identifier of the message containing the poll
MessageId int64 `json:"message_id"`
// 0-based identifiers of answer options, chosen by the user. User can choose more than 1 answer option only is the poll allows multiple answers
OptionIds []int32 `json:"option_ids"`
}
// Changes the user answer to a poll. A poll in quiz mode can be answered only once
func (client *Client) SetPollAnswer(req *SetPollAnswerRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "setPollAnswer",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"message_id": req.MessageId,
"option_ids": req.OptionIds,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type GetPollVotersRequest struct {
// Identifier of the chat to which the poll belongs
ChatId int64 `json:"chat_id"`
// Identifier of the message containing the poll
MessageId int64 `json:"message_id"`
// 0-based identifier of the answer option
OptionId int32 `json:"option_id"`
// Number of users to skip in the result; must be non-negative
Offset int32 `json:"offset"`
// The maximum number of users to be returned; must be positive and can't be greater than 50. For optimal performance, the number of returned users is chosen by TDLib and can be smaller than the specified limit, even if the end of the voter list has not been reached
Limit int32 `json:"limit"`
}
// Returns users voted for the specified option in a non-anonymous polls. For optimal performance, the number of returned users is chosen by TDLib
func (client *Client) GetPollVoters(req *GetPollVotersRequest) (*Users, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getPollVoters",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"message_id": req.MessageId,
"option_id": req.OptionId,
"offset": req.Offset,
"limit": req.Limit,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalUsers(result.Data)
}
type StopPollRequest struct {
// Identifier of the chat to which the poll belongs
ChatId int64 `json:"chat_id"`
// Identifier of the message containing the poll
MessageId int64 `json:"message_id"`
// The new message reply markup; pass null if none; for bots only
ReplyMarkup ReplyMarkup `json:"reply_markup"`
}
// Stops a poll. A poll in a message can be stopped when the message has can_be_edited flag set
func (client *Client) StopPoll(req *StopPollRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "stopPoll",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"message_id": req.MessageId,
"reply_markup": req.ReplyMarkup,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type HideSuggestedActionRequest struct {
// Suggested action to hide
Action SuggestedAction `json:"action"`
}
// Hides a suggested action
func (client *Client) HideSuggestedAction(req *HideSuggestedActionRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "hideSuggestedAction",
},
Data: map[string]interface{}{
"action": req.Action,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type GetLoginUrlInfoRequest struct {
// Chat identifier of the message with the button
ChatId int64 `json:"chat_id"`
// Message identifier of the message with the button
MessageId int64 `json:"message_id"`
// Button identifier
ButtonId int64 `json:"button_id"`
}
// Returns information about a button of type inlineKeyboardButtonTypeLoginUrl. The method needs to be called when the user presses the button
func (client *Client) GetLoginUrlInfo(req *GetLoginUrlInfoRequest) (LoginUrlInfo, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getLoginUrlInfo",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"message_id": req.MessageId,
"button_id": req.ButtonId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
switch result.Type {
case TypeLoginUrlInfoOpen:
return UnmarshalLoginUrlInfoOpen(result.Data)
case TypeLoginUrlInfoRequestConfirmation:
return UnmarshalLoginUrlInfoRequestConfirmation(result.Data)
default:
return nil, errors.New("invalid type")
}
}
type GetLoginUrlRequest struct {
// Chat identifier of the message with the button
ChatId int64 `json:"chat_id"`
// Message identifier of the message with the button
MessageId int64 `json:"message_id"`
// Button identifier
ButtonId int64 `json:"button_id"`
// Pass true to allow the bot to send messages to the current user
AllowWriteAccess bool `json:"allow_write_access"`
}
// Returns an HTTP URL which can be used to automatically authorize the user on a website after clicking an inline button of type inlineKeyboardButtonTypeLoginUrl. Use the method getLoginUrlInfo to find whether a prior user confirmation is needed. If an error is returned, then the button must be handled as an ordinary URL button
func (client *Client) GetLoginUrl(req *GetLoginUrlRequest) (*HttpUrl, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getLoginUrl",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"message_id": req.MessageId,
"button_id": req.ButtonId,
"allow_write_access": req.AllowWriteAccess,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalHttpUrl(result.Data)
}
type GetInlineQueryResultsRequest struct {
// The identifier of the target bot
BotUserId int64 `json:"bot_user_id"`
// Identifier of the chat where the query was sent
ChatId int64 `json:"chat_id"`
// Location of the user; pass null if unknown or the bot doesn't need user's location
UserLocation *Location `json:"user_location"`
// Text of the query
Query string `json:"query"`
// Offset of the first entry to return
Offset string `json:"offset"`
}
// Sends an inline query to a bot and returns its results. Returns an error with code 502 if the bot fails to answer the query before the query timeout expires
func (client *Client) GetInlineQueryResults(req *GetInlineQueryResultsRequest) (*InlineQueryResults, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getInlineQueryResults",
},
Data: map[string]interface{}{
"bot_user_id": req.BotUserId,
"chat_id": req.ChatId,
"user_location": req.UserLocation,
"query": req.Query,
"offset": req.Offset,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalInlineQueryResults(result.Data)
}
type AnswerInlineQueryRequest struct {
// Identifier of the inline query
InlineQueryId JsonInt64 `json:"inline_query_id"`
// Pass true if results may be cached and returned only for the user that sent the query. By default, results may be returned to any user who sends the same query
IsPersonal bool `json:"is_personal"`
// The results of the query
Results []InputInlineQueryResult `json:"results"`
// Allowed time to cache the results of the query, in seconds
CacheTime int32 `json:"cache_time"`
// Offset for the next inline query; pass an empty string if there are no more results
NextOffset string `json:"next_offset"`
// If non-empty, this text must be shown on the button that opens a private chat with the bot and sends a start message to the bot with the parameter switch_pm_parameter
SwitchPmText string `json:"switch_pm_text"`
// The parameter for the bot start message
SwitchPmParameter string `json:"switch_pm_parameter"`
}
// Sets the result of an inline query; for bots only
func (client *Client) AnswerInlineQuery(req *AnswerInlineQueryRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "answerInlineQuery",
},
Data: map[string]interface{}{
"inline_query_id": req.InlineQueryId,
"is_personal": req.IsPersonal,
"results": req.Results,
"cache_time": req.CacheTime,
"next_offset": req.NextOffset,
"switch_pm_text": req.SwitchPmText,
"switch_pm_parameter": req.SwitchPmParameter,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type GetWebAppUrlRequest struct {
// Identifier of the target bot
BotUserId int64 `json:"bot_user_id"`
// The URL from the keyboardButtonTypeWebApp button
Url string `json:"url"`
// Preferred web app theme; pass null to use the default theme
Theme *ThemeParameters `json:"theme"`
}
// Returns an HTTPS URL of a web app to open after keyboardButtonTypeWebApp button is pressed
func (client *Client) GetWebAppUrl(req *GetWebAppUrlRequest) (*HttpUrl, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getWebAppUrl",
},
Data: map[string]interface{}{
"bot_user_id": req.BotUserId,
"url": req.Url,
"theme": req.Theme,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalHttpUrl(result.Data)
}
type SendWebAppDataRequest struct {
// Identifier of the target bot
BotUserId int64 `json:"bot_user_id"`
// Text of the keyboardButtonTypeWebApp button, which opened the web app
ButtonText string `json:"button_text"`
// Received data
Data string `json:"data"`
}
// Sends data received from a keyboardButtonTypeWebApp web app to a bot
func (client *Client) SendWebAppData(req *SendWebAppDataRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "sendWebAppData",
},
Data: map[string]interface{}{
"bot_user_id": req.BotUserId,
"button_text": req.ButtonText,
"data": req.Data,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type OpenWebAppRequest struct {
// Identifier of the chat in which the web app is opened. Web apps can be opened only in private chats for now
ChatId int64 `json:"chat_id"`
// Identifier of the bot, providing the web app
BotUserId int64 `json:"bot_user_id"`
// The URL from an inlineKeyboardButtonTypeWebApp button, a botMenuButton button, or an internalLinkTypeAttachmentMenuBot link, or an empty string otherwise
Url string `json:"url"`
// Preferred web app theme; pass null to use the default theme
Theme *ThemeParameters `json:"theme"`
// Identifier of the replied message for the message sent by the web app; 0 if none
ReplyToMessageId int64 `json:"reply_to_message_id"`
}
// Informs TDLib that a web app is being opened from attachment menu, a botMenuButton button, an internalLinkTypeAttachmentMenuBot link, or an inlineKeyboardButtonTypeWebApp button. For each bot, a confirmation alert about data sent to the bot must be shown once
func (client *Client) OpenWebApp(req *OpenWebAppRequest) (*WebAppInfo, error) {
result, err := client.Send(Request{
meta: meta{
Type: "openWebApp",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"bot_user_id": req.BotUserId,
"url": req.Url,
"theme": req.Theme,
"reply_to_message_id": req.ReplyToMessageId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalWebAppInfo(result.Data)
}
type CloseWebAppRequest struct {
// Identifier of web app launch, received from openWebApp
WebAppLaunchId JsonInt64 `json:"web_app_launch_id"`
}
// Informs TDLib that a previously opened web app was closed
func (client *Client) CloseWebApp(req *CloseWebAppRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "closeWebApp",
},
Data: map[string]interface{}{
"web_app_launch_id": req.WebAppLaunchId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type AnswerWebAppQueryRequest struct {
// Identifier of the web app query
WebAppQueryId string `json:"web_app_query_id"`
// The result of the query
Result InputInlineQueryResult `json:"result"`
}
// Sets the result of interaction with a web app and sends corresponding message on behalf of the user to the chat from which the query originated; for bots only
func (client *Client) AnswerWebAppQuery(req *AnswerWebAppQueryRequest) (*SentWebAppMessage, error) {
result, err := client.Send(Request{
meta: meta{
Type: "answerWebAppQuery",
},
Data: map[string]interface{}{
"web_app_query_id": req.WebAppQueryId,
"result": req.Result,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalSentWebAppMessage(result.Data)
}
type GetCallbackQueryAnswerRequest struct {
// Identifier of the chat with the message
ChatId int64 `json:"chat_id"`
// Identifier of the message from which the query originated
MessageId int64 `json:"message_id"`
// Query payload
Payload CallbackQueryPayload `json:"payload"`
}
// Sends a callback query to a bot and returns an answer. Returns an error with code 502 if the bot fails to answer the query before the query timeout expires
func (client *Client) GetCallbackQueryAnswer(req *GetCallbackQueryAnswerRequest) (*CallbackQueryAnswer, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getCallbackQueryAnswer",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"message_id": req.MessageId,
"payload": req.Payload,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalCallbackQueryAnswer(result.Data)
}
type AnswerCallbackQueryRequest struct {
// Identifier of the callback query
CallbackQueryId JsonInt64 `json:"callback_query_id"`
// Text of the answer
Text string `json:"text"`
// Pass true to show an alert to the user instead of a toast notification
ShowAlert bool `json:"show_alert"`
// URL to be opened
Url string `json:"url"`
// Time during which the result of the query can be cached, in seconds
CacheTime int32 `json:"cache_time"`
}
// Sets the result of a callback query; for bots only
func (client *Client) AnswerCallbackQuery(req *AnswerCallbackQueryRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "answerCallbackQuery",
},
Data: map[string]interface{}{
"callback_query_id": req.CallbackQueryId,
"text": req.Text,
"show_alert": req.ShowAlert,
"url": req.Url,
"cache_time": req.CacheTime,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type AnswerShippingQueryRequest struct {
// Identifier of the shipping query
ShippingQueryId JsonInt64 `json:"shipping_query_id"`
// Available shipping options
ShippingOptions []*ShippingOption `json:"shipping_options"`
// An error message, empty on success
ErrorMessage string `json:"error_message"`
}
// Sets the result of a shipping query; for bots only
func (client *Client) AnswerShippingQuery(req *AnswerShippingQueryRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "answerShippingQuery",
},
Data: map[string]interface{}{
"shipping_query_id": req.ShippingQueryId,
"shipping_options": req.ShippingOptions,
"error_message": req.ErrorMessage,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type AnswerPreCheckoutQueryRequest struct {
// Identifier of the pre-checkout query
PreCheckoutQueryId JsonInt64 `json:"pre_checkout_query_id"`
// An error message, empty on success
ErrorMessage string `json:"error_message"`
}
// Sets the result of a pre-checkout query; for bots only
func (client *Client) AnswerPreCheckoutQuery(req *AnswerPreCheckoutQueryRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "answerPreCheckoutQuery",
},
Data: map[string]interface{}{
"pre_checkout_query_id": req.PreCheckoutQueryId,
"error_message": req.ErrorMessage,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type SetGameScoreRequest struct {
// The chat to which the message with the game belongs
ChatId int64 `json:"chat_id"`
// Identifier of the message
MessageId int64 `json:"message_id"`
// Pass true to edit the game message to include the current scoreboard
EditMessage bool `json:"edit_message"`
// User identifier
UserId int64 `json:"user_id"`
// The new score
Score int32 `json:"score"`
// Pass true to update the score even if it decreases. If the score is 0, the user will be deleted from the high score table
Force bool `json:"force"`
}
// Updates the game score of the specified user in the game; for bots only
func (client *Client) SetGameScore(req *SetGameScoreRequest) (*Message, error) {
result, err := client.Send(Request{
meta: meta{
Type: "setGameScore",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"message_id": req.MessageId,
"edit_message": req.EditMessage,
"user_id": req.UserId,
"score": req.Score,
"force": req.Force,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalMessage(result.Data)
}
type SetInlineGameScoreRequest struct {
// Inline message identifier
InlineMessageId string `json:"inline_message_id"`
// Pass true to edit the game message to include the current scoreboard
EditMessage bool `json:"edit_message"`
// User identifier
UserId int64 `json:"user_id"`
// The new score
Score int32 `json:"score"`
// Pass true to update the score even if it decreases. If the score is 0, the user will be deleted from the high score table
Force bool `json:"force"`
}
// Updates the game score of the specified user in a game; for bots only
func (client *Client) SetInlineGameScore(req *SetInlineGameScoreRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "setInlineGameScore",
},
Data: map[string]interface{}{
"inline_message_id": req.InlineMessageId,
"edit_message": req.EditMessage,
"user_id": req.UserId,
"score": req.Score,
"force": req.Force,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type GetGameHighScoresRequest struct {
// The chat that contains the message with the game
ChatId int64 `json:"chat_id"`
// Identifier of the message
MessageId int64 `json:"message_id"`
// User identifier
UserId int64 `json:"user_id"`
}
// Returns the high scores for a game and some part of the high score table in the range of the specified user; for bots only
func (client *Client) GetGameHighScores(req *GetGameHighScoresRequest) (*GameHighScores, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getGameHighScores",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"message_id": req.MessageId,
"user_id": req.UserId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalGameHighScores(result.Data)
}
type GetInlineGameHighScoresRequest struct {
// Inline message identifier
InlineMessageId string `json:"inline_message_id"`
// User identifier
UserId int64 `json:"user_id"`
}
// Returns game high scores and some part of the high score table in the range of the specified user; for bots only
func (client *Client) GetInlineGameHighScores(req *GetInlineGameHighScoresRequest) (*GameHighScores, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getInlineGameHighScores",
},
Data: map[string]interface{}{
"inline_message_id": req.InlineMessageId,
"user_id": req.UserId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalGameHighScores(result.Data)
}
type DeleteChatReplyMarkupRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
// The message identifier of the used keyboard
MessageId int64 `json:"message_id"`
}
// Deletes the default reply markup from a chat. Must be called after a one-time keyboard or a ForceReply reply markup has been used. UpdateChatReplyMarkup will be sent if the reply markup is changed
func (client *Client) DeleteChatReplyMarkup(req *DeleteChatReplyMarkupRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "deleteChatReplyMarkup",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"message_id": req.MessageId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type SendChatActionRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
// If not 0, a message thread identifier in which the action was performed
MessageThreadId int64 `json:"message_thread_id"`
// The action description; pass null to cancel the currently active action
Action ChatAction `json:"action"`
}
// Sends a notification about user activity in a chat
func (client *Client) SendChatAction(req *SendChatActionRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "sendChatAction",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"message_thread_id": req.MessageThreadId,
"action": req.Action,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type OpenChatRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
}
// Informs TDLib that the chat is opened by the user. Many useful activities depend on the chat being opened or closed (e.g., in supergroups and channels all updates are received only for opened chats)
func (client *Client) OpenChat(req *OpenChatRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "openChat",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type CloseChatRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
}
// Informs TDLib that the chat is closed by the user. Many useful activities depend on the chat being opened or closed
func (client *Client) CloseChat(req *CloseChatRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "closeChat",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type ViewMessagesRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
// If not 0, a message thread identifier in which the messages are being viewed
MessageThreadId int64 `json:"message_thread_id"`
// The identifiers of the messages being viewed
MessageIds []int64 `json:"message_ids"`
// Pass true to mark as read the specified messages even the chat is closed
ForceRead bool `json:"force_read"`
}
// Informs TDLib that messages are being viewed by the user. Sponsored messages must be marked as viewed only when the entire text of the message is shown on the screen (excluding the button). Many useful activities depend on whether the messages are currently being viewed or not (e.g., marking messages as read, incrementing a view counter, updating a view counter, removing deleted messages in supergroups and channels)
func (client *Client) ViewMessages(req *ViewMessagesRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "viewMessages",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"message_thread_id": req.MessageThreadId,
"message_ids": req.MessageIds,
"force_read": req.ForceRead,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type OpenMessageContentRequest struct {
// Chat identifier of the message
ChatId int64 `json:"chat_id"`
// Identifier of the message with the opened content
MessageId int64 `json:"message_id"`
}
// Informs TDLib that the message content has been opened (e.g., the user has opened a photo, video, document, location or venue, or has listened to an audio file or voice note message). An updateMessageContentOpened update will be generated if something has changed
func (client *Client) OpenMessageContent(req *OpenMessageContentRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "openMessageContent",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"message_id": req.MessageId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type ClickAnimatedEmojiMessageRequest struct {
// Chat identifier of the message
ChatId int64 `json:"chat_id"`
// Identifier of the clicked message
MessageId int64 `json:"message_id"`
}
// Informs TDLib that a message with an animated emoji was clicked by the user. Returns a big animated sticker to be played or a 404 error if usual animation needs to be played
func (client *Client) ClickAnimatedEmojiMessage(req *ClickAnimatedEmojiMessageRequest) (*Sticker, error) {
result, err := client.Send(Request{
meta: meta{
Type: "clickAnimatedEmojiMessage",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"message_id": req.MessageId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalSticker(result.Data)
}
type GetInternalLinkTypeRequest struct {
// The link
Link string `json:"link"`
}
// Returns information about the type of an internal link. Returns a 404 error if the link is not internal. Can be called before authorization
func (client *Client) GetInternalLinkType(req *GetInternalLinkTypeRequest) (InternalLinkType, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getInternalLinkType",
},
Data: map[string]interface{}{
"link": req.Link,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
switch result.Type {
case TypeInternalLinkTypeActiveSessions:
return UnmarshalInternalLinkTypeActiveSessions(result.Data)
case TypeInternalLinkTypeAttachmentMenuBot:
return UnmarshalInternalLinkTypeAttachmentMenuBot(result.Data)
case TypeInternalLinkTypeAuthenticationCode:
return UnmarshalInternalLinkTypeAuthenticationCode(result.Data)
case TypeInternalLinkTypeBackground:
return UnmarshalInternalLinkTypeBackground(result.Data)
case TypeInternalLinkTypeBotStart:
return UnmarshalInternalLinkTypeBotStart(result.Data)
case TypeInternalLinkTypeBotStartInGroup:
return UnmarshalInternalLinkTypeBotStartInGroup(result.Data)
case TypeInternalLinkTypeBotAddToChannel:
return UnmarshalInternalLinkTypeBotAddToChannel(result.Data)
case TypeInternalLinkTypeChangePhoneNumber:
return UnmarshalInternalLinkTypeChangePhoneNumber(result.Data)
case TypeInternalLinkTypeChatInvite:
return UnmarshalInternalLinkTypeChatInvite(result.Data)
case TypeInternalLinkTypeFilterSettings:
return UnmarshalInternalLinkTypeFilterSettings(result.Data)
case TypeInternalLinkTypeGame:
return UnmarshalInternalLinkTypeGame(result.Data)
case TypeInternalLinkTypeLanguagePack:
return UnmarshalInternalLinkTypeLanguagePack(result.Data)
case TypeInternalLinkTypeLanguageSettings:
return UnmarshalInternalLinkTypeLanguageSettings(result.Data)
case TypeInternalLinkTypeMessage:
return UnmarshalInternalLinkTypeMessage(result.Data)
case TypeInternalLinkTypeMessageDraft:
return UnmarshalInternalLinkTypeMessageDraft(result.Data)
case TypeInternalLinkTypePassportDataRequest:
return UnmarshalInternalLinkTypePassportDataRequest(result.Data)
case TypeInternalLinkTypePhoneNumberConfirmation:
return UnmarshalInternalLinkTypePhoneNumberConfirmation(result.Data)
case TypeInternalLinkTypePrivacyAndSecuritySettings:
return UnmarshalInternalLinkTypePrivacyAndSecuritySettings(result.Data)
case TypeInternalLinkTypeProxy:
return UnmarshalInternalLinkTypeProxy(result.Data)
case TypeInternalLinkTypePublicChat:
return UnmarshalInternalLinkTypePublicChat(result.Data)
case TypeInternalLinkTypeQrCodeAuthentication:
return UnmarshalInternalLinkTypeQrCodeAuthentication(result.Data)
case TypeInternalLinkTypeSettings:
return UnmarshalInternalLinkTypeSettings(result.Data)
case TypeInternalLinkTypeStickerSet:
return UnmarshalInternalLinkTypeStickerSet(result.Data)
case TypeInternalLinkTypeTheme:
return UnmarshalInternalLinkTypeTheme(result.Data)
case TypeInternalLinkTypeThemeSettings:
return UnmarshalInternalLinkTypeThemeSettings(result.Data)
case TypeInternalLinkTypeUnknownDeepLink:
return UnmarshalInternalLinkTypeUnknownDeepLink(result.Data)
case TypeInternalLinkTypeUnsupportedProxy:
return UnmarshalInternalLinkTypeUnsupportedProxy(result.Data)
case TypeInternalLinkTypeUserPhoneNumber:
return UnmarshalInternalLinkTypeUserPhoneNumber(result.Data)
case TypeInternalLinkTypeVideoChat:
return UnmarshalInternalLinkTypeVideoChat(result.Data)
default:
return nil, errors.New("invalid type")
}
}
type GetExternalLinkInfoRequest struct {
// The link
Link string `json:"link"`
}
// Returns information about an action to be done when the current user clicks an external link. Don't use this method for links from secret chats if web page preview is disabled in secret chats
func (client *Client) GetExternalLinkInfo(req *GetExternalLinkInfoRequest) (LoginUrlInfo, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getExternalLinkInfo",
},
Data: map[string]interface{}{
"link": req.Link,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
switch result.Type {
case TypeLoginUrlInfoOpen:
return UnmarshalLoginUrlInfoOpen(result.Data)
case TypeLoginUrlInfoRequestConfirmation:
return UnmarshalLoginUrlInfoRequestConfirmation(result.Data)
default:
return nil, errors.New("invalid type")
}
}
type GetExternalLinkRequest struct {
// The HTTP link
Link string `json:"link"`
// Pass true if the current user allowed the bot, returned in getExternalLinkInfo, to send them messages
AllowWriteAccess bool `json:"allow_write_access"`
}
// Returns an HTTP URL which can be used to automatically authorize the current user on a website after clicking an HTTP link. Use the method getExternalLinkInfo to find whether a prior user confirmation is needed
func (client *Client) GetExternalLink(req *GetExternalLinkRequest) (*HttpUrl, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getExternalLink",
},
Data: map[string]interface{}{
"link": req.Link,
"allow_write_access": req.AllowWriteAccess,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalHttpUrl(result.Data)
}
type ReadAllChatMentionsRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
}
// Marks all mentions in a chat as read
func (client *Client) ReadAllChatMentions(req *ReadAllChatMentionsRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "readAllChatMentions",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type ReadAllChatReactionsRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
}
// Marks all reactions in a chat as read
func (client *Client) ReadAllChatReactions(req *ReadAllChatReactionsRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "readAllChatReactions",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type CreatePrivateChatRequest struct {
// User identifier
UserId int64 `json:"user_id"`
// Pass true to create the chat without a network request. In this case all information about the chat except its type, title and photo can be incorrect
Force bool `json:"force"`
}
// Returns an existing chat corresponding to a given user
func (client *Client) CreatePrivateChat(req *CreatePrivateChatRequest) (*Chat, error) {
result, err := client.Send(Request{
meta: meta{
Type: "createPrivateChat",
},
Data: map[string]interface{}{
"user_id": req.UserId,
"force": req.Force,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalChat(result.Data)
}
type CreateBasicGroupChatRequest struct {
// Basic group identifier
BasicGroupId int64 `json:"basic_group_id"`
// Pass true to create the chat without a network request. In this case all information about the chat except its type, title and photo can be incorrect
Force bool `json:"force"`
}
// Returns an existing chat corresponding to a known basic group
func (client *Client) CreateBasicGroupChat(req *CreateBasicGroupChatRequest) (*Chat, error) {
result, err := client.Send(Request{
meta: meta{
Type: "createBasicGroupChat",
},
Data: map[string]interface{}{
"basic_group_id": req.BasicGroupId,
"force": req.Force,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalChat(result.Data)
}
type CreateSupergroupChatRequest struct {
// Supergroup or channel identifier
SupergroupId int64 `json:"supergroup_id"`
// Pass true to create the chat without a network request. In this case all information about the chat except its type, title and photo can be incorrect
Force bool `json:"force"`
}
// Returns an existing chat corresponding to a known supergroup or channel
func (client *Client) CreateSupergroupChat(req *CreateSupergroupChatRequest) (*Chat, error) {
result, err := client.Send(Request{
meta: meta{
Type: "createSupergroupChat",
},
Data: map[string]interface{}{
"supergroup_id": req.SupergroupId,
"force": req.Force,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalChat(result.Data)
}
type CreateSecretChatRequest struct {
// Secret chat identifier
SecretChatId int32 `json:"secret_chat_id"`
}
// Returns an existing chat corresponding to a known secret chat
func (client *Client) CreateSecretChat(req *CreateSecretChatRequest) (*Chat, error) {
result, err := client.Send(Request{
meta: meta{
Type: "createSecretChat",
},
Data: map[string]interface{}{
"secret_chat_id": req.SecretChatId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalChat(result.Data)
}
type CreateNewBasicGroupChatRequest struct {
// Identifiers of users to be added to the basic group
UserIds []int64 `json:"user_ids"`
// Title of the new basic group; 1-128 characters
Title string `json:"title"`
}
// Creates a new basic group and sends a corresponding messageBasicGroupChatCreate. Returns the newly created chat
func (client *Client) CreateNewBasicGroupChat(req *CreateNewBasicGroupChatRequest) (*Chat, error) {
result, err := client.Send(Request{
meta: meta{
Type: "createNewBasicGroupChat",
},
Data: map[string]interface{}{
"user_ids": req.UserIds,
"title": req.Title,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalChat(result.Data)
}
type CreateNewSupergroupChatRequest struct {
// Title of the new chat; 1-128 characters
Title string `json:"title"`
// Pass true to create a channel chat
IsChannel bool `json:"is_channel"`
// Chat description; 0-255 characters
Description string `json:"description"`
// Chat location if a location-based supergroup is being created; pass null to create an ordinary supergroup chat
Location *ChatLocation `json:"location"`
// Pass true to create a supergroup for importing messages using importMessage
ForImport bool `json:"for_import"`
}
// Creates a new supergroup or channel and sends a corresponding messageSupergroupChatCreate. Returns the newly created chat
func (client *Client) CreateNewSupergroupChat(req *CreateNewSupergroupChatRequest) (*Chat, error) {
result, err := client.Send(Request{
meta: meta{
Type: "createNewSupergroupChat",
},
Data: map[string]interface{}{
"title": req.Title,
"is_channel": req.IsChannel,
"description": req.Description,
"location": req.Location,
"for_import": req.ForImport,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalChat(result.Data)
}
type CreateNewSecretChatRequest struct {
// Identifier of the target user
UserId int64 `json:"user_id"`
}
// Creates a new secret chat. Returns the newly created chat
func (client *Client) CreateNewSecretChat(req *CreateNewSecretChatRequest) (*Chat, error) {
result, err := client.Send(Request{
meta: meta{
Type: "createNewSecretChat",
},
Data: map[string]interface{}{
"user_id": req.UserId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalChat(result.Data)
}
type UpgradeBasicGroupChatToSupergroupChatRequest struct {
// Identifier of the chat to upgrade
ChatId int64 `json:"chat_id"`
}
// Creates a new supergroup from an existing basic group and sends a corresponding messageChatUpgradeTo and messageChatUpgradeFrom; requires creator privileges. Deactivates the original basic group
func (client *Client) UpgradeBasicGroupChatToSupergroupChat(req *UpgradeBasicGroupChatToSupergroupChatRequest) (*Chat, error) {
result, err := client.Send(Request{
meta: meta{
Type: "upgradeBasicGroupChatToSupergroupChat",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalChat(result.Data)
}
type GetChatListsToAddChatRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
}
// Returns chat lists to which the chat can be added. This is an offline request
func (client *Client) GetChatListsToAddChat(req *GetChatListsToAddChatRequest) (*ChatLists, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getChatListsToAddChat",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalChatLists(result.Data)
}
type AddChatToListRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
// The chat list. Use getChatListsToAddChat to get suitable chat lists
ChatList ChatList `json:"chat_list"`
}
// Adds a chat to a chat list. A chat can't be simultaneously in Main and Archive chat lists, so it is automatically removed from another one if needed
func (client *Client) AddChatToList(req *AddChatToListRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "addChatToList",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"chat_list": req.ChatList,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type GetChatFilterRequest struct {
// Chat filter identifier
ChatFilterId int32 `json:"chat_filter_id"`
}
// Returns information about a chat filter by its identifier
func (client *Client) GetChatFilter(req *GetChatFilterRequest) (*ChatFilter, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getChatFilter",
},
Data: map[string]interface{}{
"chat_filter_id": req.ChatFilterId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalChatFilter(result.Data)
}
type CreateChatFilterRequest struct {
// Chat filter
Filter *ChatFilter `json:"filter"`
}
// Creates new chat filter. Returns information about the created chat filter
func (client *Client) CreateChatFilter(req *CreateChatFilterRequest) (*ChatFilterInfo, error) {
result, err := client.Send(Request{
meta: meta{
Type: "createChatFilter",
},
Data: map[string]interface{}{
"filter": req.Filter,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalChatFilterInfo(result.Data)
}
type EditChatFilterRequest struct {
// Chat filter identifier
ChatFilterId int32 `json:"chat_filter_id"`
// The edited chat filter
Filter *ChatFilter `json:"filter"`
}
// Edits existing chat filter. Returns information about the edited chat filter
func (client *Client) EditChatFilter(req *EditChatFilterRequest) (*ChatFilterInfo, error) {
result, err := client.Send(Request{
meta: meta{
Type: "editChatFilter",
},
Data: map[string]interface{}{
"chat_filter_id": req.ChatFilterId,
"filter": req.Filter,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalChatFilterInfo(result.Data)
}
type DeleteChatFilterRequest struct {
// Chat filter identifier
ChatFilterId int32 `json:"chat_filter_id"`
}
// Deletes existing chat filter
func (client *Client) DeleteChatFilter(req *DeleteChatFilterRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "deleteChatFilter",
},
Data: map[string]interface{}{
"chat_filter_id": req.ChatFilterId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type ReorderChatFiltersRequest struct {
// Identifiers of chat filters in the new correct order
ChatFilterIds []int32 `json:"chat_filter_ids"`
}
// Changes the order of chat filters
func (client *Client) ReorderChatFilters(req *ReorderChatFiltersRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "reorderChatFilters",
},
Data: map[string]interface{}{
"chat_filter_ids": req.ChatFilterIds,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
// Returns recommended chat filters for the current user
func (client *Client) GetRecommendedChatFilters() (*RecommendedChatFilters, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getRecommendedChatFilters",
},
Data: map[string]interface{}{},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalRecommendedChatFilters(result.Data)
}
type GetChatFilterDefaultIconNameRequest struct {
// Chat filter
Filter *ChatFilter `json:"filter"`
}
// Returns default icon name for a filter. Can be called synchronously
func GetChatFilterDefaultIconName(req *GetChatFilterDefaultIconNameRequest) (*Text, error) {
result, err := Execute(Request{
meta: meta{
Type: "getChatFilterDefaultIconName",
},
Data: map[string]interface{}{
"filter": req.Filter,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalText(result.Data)
}
// deprecated
// Returns default icon name for a filter. Can be called synchronously
func (client *Client) GetChatFilterDefaultIconName(req *GetChatFilterDefaultIconNameRequest) (*Text, error) {
return GetChatFilterDefaultIconName(req)}
type SetChatTitleRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
// New title of the chat; 1-128 characters
Title string `json:"title"`
}
// Changes the chat title. Supported only for basic groups, supergroups and channels. Requires can_change_info administrator right
func (client *Client) SetChatTitle(req *SetChatTitleRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "setChatTitle",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"title": req.Title,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type SetChatPhotoRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
// New chat photo; pass null to delete the chat photo
Photo InputChatPhoto `json:"photo"`
}
// Changes the photo of a chat. Supported only for basic groups, supergroups and channels. Requires can_change_info administrator right
func (client *Client) SetChatPhoto(req *SetChatPhotoRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "setChatPhoto",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"photo": req.Photo,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type SetChatMessageTtlRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
// New TTL value, in seconds; unless the chat is secret, it must be from 0 up to 365 * 86400 and be divisible by 86400
Ttl int32 `json:"ttl"`
}
// Changes the message TTL in a chat. Requires can_delete_messages administrator right in basic groups, supergroups and channels Message TTL can't be changed in a chat with the current user (Saved Messages) and the chat 777000 (Telegram).
func (client *Client) SetChatMessageTtl(req *SetChatMessageTtlRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "setChatMessageTtl",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"ttl": req.Ttl,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type SetChatPermissionsRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
// New non-administrator members permissions in the chat
Permissions *ChatPermissions `json:"permissions"`
}
// Changes the chat members permissions. Supported only for basic groups and supergroups. Requires can_restrict_members administrator right
func (client *Client) SetChatPermissions(req *SetChatPermissionsRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "setChatPermissions",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"permissions": req.Permissions,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type SetChatThemeRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
// Name of the new chat theme; pass an empty string to return the default theme
ThemeName string `json:"theme_name"`
}
// Changes the chat theme. Supported only in private and secret chats
func (client *Client) SetChatTheme(req *SetChatThemeRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "setChatTheme",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"theme_name": req.ThemeName,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type SetChatDraftMessageRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
// If not 0, a message thread identifier in which the draft was changed
MessageThreadId int64 `json:"message_thread_id"`
// New draft message; pass null to remove the draft
DraftMessage *DraftMessage `json:"draft_message"`
}
// Changes the draft message in a chat
func (client *Client) SetChatDraftMessage(req *SetChatDraftMessageRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "setChatDraftMessage",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"message_thread_id": req.MessageThreadId,
"draft_message": req.DraftMessage,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type SetChatNotificationSettingsRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
// New notification settings for the chat. If the chat is muted for more than 1 week, it is considered to be muted forever
NotificationSettings *ChatNotificationSettings `json:"notification_settings"`
}
// Changes the notification settings of a chat. Notification settings of a chat with the current user (Saved Messages) can't be changed
func (client *Client) SetChatNotificationSettings(req *SetChatNotificationSettingsRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "setChatNotificationSettings",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"notification_settings": req.NotificationSettings,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type ToggleChatHasProtectedContentRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
// New value of has_protected_content
HasProtectedContent bool `json:"has_protected_content"`
}
// Changes the ability of users to save, forward, or copy chat content. Supported only for basic groups, supergroups and channels. Requires owner privileges
func (client *Client) ToggleChatHasProtectedContent(req *ToggleChatHasProtectedContentRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "toggleChatHasProtectedContent",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"has_protected_content": req.HasProtectedContent,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type ToggleChatIsMarkedAsUnreadRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
// New value of is_marked_as_unread
IsMarkedAsUnread bool `json:"is_marked_as_unread"`
}
// Changes the marked as unread state of a chat
func (client *Client) ToggleChatIsMarkedAsUnread(req *ToggleChatIsMarkedAsUnreadRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "toggleChatIsMarkedAsUnread",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"is_marked_as_unread": req.IsMarkedAsUnread,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type ToggleChatDefaultDisableNotificationRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
// New value of default_disable_notification
DefaultDisableNotification bool `json:"default_disable_notification"`
}
// Changes the value of the default disable_notification parameter, used when a message is sent to a chat
func (client *Client) ToggleChatDefaultDisableNotification(req *ToggleChatDefaultDisableNotificationRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "toggleChatDefaultDisableNotification",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"default_disable_notification": req.DefaultDisableNotification,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type SetChatAvailableReactionsRequest struct {
// Identifier of the chat
ChatId int64 `json:"chat_id"`
// New list of reactions, available in the chat. All reactions must be active
AvailableReactions []string `json:"available_reactions"`
}
// Changes reactions, available in a chat. Available for basic groups, supergroups, and channels. Requires can_change_info administrator right
func (client *Client) SetChatAvailableReactions(req *SetChatAvailableReactionsRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "setChatAvailableReactions",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"available_reactions": req.AvailableReactions,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type SetChatClientDataRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
// New value of client_data
ClientData string `json:"client_data"`
}
// Changes application-specific data associated with a chat
func (client *Client) SetChatClientData(req *SetChatClientDataRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "setChatClientData",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"client_data": req.ClientData,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type SetChatDescriptionRequest struct {
// Identifier of the chat
ChatId int64 `json:"chat_id"`
// New chat description; 0-255 characters
Description string `json:"description"`
}
// Changes information about a chat. Available for basic groups, supergroups, and channels. Requires can_change_info administrator right
func (client *Client) SetChatDescription(req *SetChatDescriptionRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "setChatDescription",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"description": req.Description,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type SetChatDiscussionGroupRequest struct {
// Identifier of the channel chat. Pass 0 to remove a link from the supergroup passed in the second argument to a linked channel chat (requires can_pin_messages rights in the supergroup)
ChatId int64 `json:"chat_id"`
// Identifier of a new channel's discussion group. Use 0 to remove the discussion group. Use the method getSuitableDiscussionChats to find all suitable groups. Basic group chats must be first upgraded to supergroup chats. If new chat members don't have access to old messages in the supergroup, then toggleSupergroupIsAllHistoryAvailable must be used first to change that
DiscussionChatId int64 `json:"discussion_chat_id"`
}
// Changes the discussion group of a channel chat; requires can_change_info administrator right in the channel if it is specified
func (client *Client) SetChatDiscussionGroup(req *SetChatDiscussionGroupRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "setChatDiscussionGroup",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"discussion_chat_id": req.DiscussionChatId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type SetChatLocationRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
// New location for the chat; must be valid and not null
Location *ChatLocation `json:"location"`
}
// Changes the location of a chat. Available only for some location-based supergroups, use supergroupFullInfo.can_set_location to check whether the method is allowed to use
func (client *Client) SetChatLocation(req *SetChatLocationRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "setChatLocation",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"location": req.Location,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type SetChatSlowModeDelayRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
// New slow mode delay for the chat, in seconds; must be one of 0, 10, 30, 60, 300, 900, 3600
SlowModeDelay int32 `json:"slow_mode_delay"`
}
// Changes the slow mode delay of a chat. Available only for supergroups; requires can_restrict_members rights
func (client *Client) SetChatSlowModeDelay(req *SetChatSlowModeDelayRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "setChatSlowModeDelay",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"slow_mode_delay": req.SlowModeDelay,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type PinChatMessageRequest struct {
// Identifier of the chat
ChatId int64 `json:"chat_id"`
// Identifier of the new pinned message
MessageId int64 `json:"message_id"`
// Pass true to disable notification about the pinned message. Notifications are always disabled in channels and private chats
DisableNotification bool `json:"disable_notification"`
// Pass true to pin the message only for self; private chats only
OnlyForSelf bool `json:"only_for_self"`
}
// Pins a message in a chat; requires can_pin_messages rights or can_edit_messages rights in the channel
func (client *Client) PinChatMessage(req *PinChatMessageRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "pinChatMessage",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"message_id": req.MessageId,
"disable_notification": req.DisableNotification,
"only_for_self": req.OnlyForSelf,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type UnpinChatMessageRequest struct {
// Identifier of the chat
ChatId int64 `json:"chat_id"`
// Identifier of the removed pinned message
MessageId int64 `json:"message_id"`
}
// Removes a pinned message from a chat; requires can_pin_messages rights in the group or can_edit_messages rights in the channel
func (client *Client) UnpinChatMessage(req *UnpinChatMessageRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "unpinChatMessage",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"message_id": req.MessageId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type UnpinAllChatMessagesRequest struct {
// Identifier of the chat
ChatId int64 `json:"chat_id"`
}
// Removes all pinned messages from a chat; requires can_pin_messages rights in the group or can_edit_messages rights in the channel
func (client *Client) UnpinAllChatMessages(req *UnpinAllChatMessagesRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "unpinAllChatMessages",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type JoinChatRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
}
// Adds the current user as a new member to a chat. Private and secret chats can't be joined using this method
func (client *Client) JoinChat(req *JoinChatRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "joinChat",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type LeaveChatRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
}
// Removes the current user from chat members. Private and secret chats can't be left using this method
func (client *Client) LeaveChat(req *LeaveChatRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "leaveChat",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type AddChatMemberRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
// Identifier of the user
UserId int64 `json:"user_id"`
// The number of earlier messages from the chat to be forwarded to the new member; up to 100. Ignored for supergroups and channels, or if the added user is a bot
ForwardLimit int32 `json:"forward_limit"`
}
// Adds a new member to a chat. Members can't be added to private or secret chats
func (client *Client) AddChatMember(req *AddChatMemberRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "addChatMember",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"user_id": req.UserId,
"forward_limit": req.ForwardLimit,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type AddChatMembersRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
// Identifiers of the users to be added to the chat. The maximum number of added users is 20 for supergroups and 100 for channels
UserIds []int64 `json:"user_ids"`
}
// Adds multiple new members to a chat. Currently, this method is only available for supergroups and channels. This method can't be used to join a chat. Members can't be added to a channel if it has more than 200 members
func (client *Client) AddChatMembers(req *AddChatMembersRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "addChatMembers",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"user_ids": req.UserIds,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type SetChatMemberStatusRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
// Member identifier. Chats can be only banned and unbanned in supergroups and channels
MemberId MessageSender `json:"member_id"`
// The new status of the member in the chat
Status ChatMemberStatus `json:"status"`
}
// Changes the status of a chat member, needs appropriate privileges. This function is currently not suitable for transferring chat ownership; use transferChatOwnership instead. Use addChatMember or banChatMember if some additional parameters needs to be passed
func (client *Client) SetChatMemberStatus(req *SetChatMemberStatusRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "setChatMemberStatus",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"member_id": req.MemberId,
"status": req.Status,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type BanChatMemberRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
// Member identifier
MemberId MessageSender `json:"member_id"`
// Point in time (Unix timestamp) when the user will be unbanned; 0 if never. If the user is banned for more than 366 days or for less than 30 seconds from the current time, the user is considered to be banned forever. Ignored in basic groups and if a chat is banned
BannedUntilDate int32 `json:"banned_until_date"`
// Pass true to delete all messages in the chat for the user that is being removed. Always true for supergroups and channels
RevokeMessages bool `json:"revoke_messages"`
}
// Bans a member in a chat. Members can't be banned in private or secret chats. In supergroups and channels, the user will not be able to return to the group on their own using invite links, etc., unless unbanned first
func (client *Client) BanChatMember(req *BanChatMemberRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "banChatMember",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"member_id": req.MemberId,
"banned_until_date": req.BannedUntilDate,
"revoke_messages": req.RevokeMessages,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
// Checks whether the current session can be used to transfer a chat ownership to another user
func (client *Client) CanTransferOwnership() (CanTransferOwnershipResult, error) {
result, err := client.Send(Request{
meta: meta{
Type: "canTransferOwnership",
},
Data: map[string]interface{}{},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
switch result.Type {
case TypeCanTransferOwnershipResultOk:
return UnmarshalCanTransferOwnershipResultOk(result.Data)
case TypeCanTransferOwnershipResultPasswordNeeded:
return UnmarshalCanTransferOwnershipResultPasswordNeeded(result.Data)
case TypeCanTransferOwnershipResultPasswordTooFresh:
return UnmarshalCanTransferOwnershipResultPasswordTooFresh(result.Data)
case TypeCanTransferOwnershipResultSessionTooFresh:
return UnmarshalCanTransferOwnershipResultSessionTooFresh(result.Data)
default:
return nil, errors.New("invalid type")
}
}
type TransferChatOwnershipRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
// Identifier of the user to which transfer the ownership. The ownership can't be transferred to a bot or to a deleted user
UserId int64 `json:"user_id"`
// The password of the current user
Password string `json:"password"`
}
// Changes the owner of a chat. The current user must be a current owner of the chat. Use the method canTransferOwnership to check whether the ownership can be transferred from the current session. Available only for supergroups and channel chats
func (client *Client) TransferChatOwnership(req *TransferChatOwnershipRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "transferChatOwnership",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"user_id": req.UserId,
"password": req.Password,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type GetChatMemberRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
// Member identifier
MemberId MessageSender `json:"member_id"`
}
// Returns information about a single member of a chat
func (client *Client) GetChatMember(req *GetChatMemberRequest) (*ChatMember, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getChatMember",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"member_id": req.MemberId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalChatMember(result.Data)
}
type SearchChatMembersRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
// Query to search for
Query string `json:"query"`
// The maximum number of users to be returned; up to 200
Limit int32 `json:"limit"`
// The type of users to search for; pass null to search among all chat members
Filter ChatMembersFilter `json:"filter"`
}
// Searches for a specified query in the first name, last name and username of the members of a specified chat. Requires administrator rights in channels
func (client *Client) SearchChatMembers(req *SearchChatMembersRequest) (*ChatMembers, error) {
result, err := client.Send(Request{
meta: meta{
Type: "searchChatMembers",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"query": req.Query,
"limit": req.Limit,
"filter": req.Filter,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalChatMembers(result.Data)
}
type GetChatAdministratorsRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
}
// Returns a list of administrators of the chat with their custom titles
func (client *Client) GetChatAdministrators(req *GetChatAdministratorsRequest) (*ChatAdministrators, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getChatAdministrators",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalChatAdministrators(result.Data)
}
type ClearAllDraftMessagesRequest struct {
// Pass true to keep local message drafts in secret chats
ExcludeSecretChats bool `json:"exclude_secret_chats"`
}
// Clears message drafts in all chats
func (client *Client) ClearAllDraftMessages(req *ClearAllDraftMessagesRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "clearAllDraftMessages",
},
Data: map[string]interface{}{
"exclude_secret_chats": req.ExcludeSecretChats,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type GetSavedNotificationSoundRequest struct {
// Identifier of the notification sound
NotificationSoundId JsonInt64 `json:"notification_sound_id"`
}
// Returns saved notification sound by its identifier. Returns a 404 error if there is no saved notification sound with the specified identifier
func (client *Client) GetSavedNotificationSound(req *GetSavedNotificationSoundRequest) (*NotificationSounds, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getSavedNotificationSound",
},
Data: map[string]interface{}{
"notification_sound_id": req.NotificationSoundId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalNotificationSounds(result.Data)
}
// Returns list of saved notification sounds. If a sound isn't in the list, then default sound needs to be used
func (client *Client) GetSavedNotificationSounds() (*NotificationSounds, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getSavedNotificationSounds",
},
Data: map[string]interface{}{},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalNotificationSounds(result.Data)
}
type AddSavedNotificationSoundRequest struct {
// Notification sound file to add
Sound InputFile `json:"sound"`
}
// Adds a new notification sound to the list of saved notification sounds. The new notification sound is added to the top of the list. If it is already in the list, its position isn't changed
func (client *Client) AddSavedNotificationSound(req *AddSavedNotificationSoundRequest) (*NotificationSound, error) {
result, err := client.Send(Request{
meta: meta{
Type: "addSavedNotificationSound",
},
Data: map[string]interface{}{
"sound": req.Sound,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalNotificationSound(result.Data)
}
type RemoveSavedNotificationSoundRequest struct {
// Identifier of the notification sound
NotificationSoundId JsonInt64 `json:"notification_sound_id"`
}
// Removes a notification sound from the list of saved notification sounds
func (client *Client) RemoveSavedNotificationSound(req *RemoveSavedNotificationSoundRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "removeSavedNotificationSound",
},
Data: map[string]interface{}{
"notification_sound_id": req.NotificationSoundId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type GetChatNotificationSettingsExceptionsRequest struct {
// If specified, only chats from the scope will be returned; pass null to return chats from all scopes
Scope NotificationSettingsScope `json:"scope"`
// Pass true to include in the response chats with only non-default sound
CompareSound bool `json:"compare_sound"`
}
// Returns list of chats with non-default notification settings
func (client *Client) GetChatNotificationSettingsExceptions(req *GetChatNotificationSettingsExceptionsRequest) (*Chats, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getChatNotificationSettingsExceptions",
},
Data: map[string]interface{}{
"scope": req.Scope,
"compare_sound": req.CompareSound,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalChats(result.Data)
}
type GetScopeNotificationSettingsRequest struct {
// Types of chats for which to return the notification settings information
Scope NotificationSettingsScope `json:"scope"`
}
// Returns the notification settings for chats of a given type
func (client *Client) GetScopeNotificationSettings(req *GetScopeNotificationSettingsRequest) (*ScopeNotificationSettings, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getScopeNotificationSettings",
},
Data: map[string]interface{}{
"scope": req.Scope,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalScopeNotificationSettings(result.Data)
}
type SetScopeNotificationSettingsRequest struct {
// Types of chats for which to change the notification settings
Scope NotificationSettingsScope `json:"scope"`
// The new notification settings for the given scope
NotificationSettings *ScopeNotificationSettings `json:"notification_settings"`
}
// Changes notification settings for chats of a given type
func (client *Client) SetScopeNotificationSettings(req *SetScopeNotificationSettingsRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "setScopeNotificationSettings",
},
Data: map[string]interface{}{
"scope": req.Scope,
"notification_settings": req.NotificationSettings,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
// Resets all notification settings to their default values. By default, all chats are unmuted and message previews are shown
func (client *Client) ResetAllNotificationSettings() (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "resetAllNotificationSettings",
},
Data: map[string]interface{}{},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type ToggleChatIsPinnedRequest struct {
// Chat list in which to change the pinned state of the chat
ChatList ChatList `json:"chat_list"`
// Chat identifier
ChatId int64 `json:"chat_id"`
// Pass true to pin the chat; pass false to unpin it
IsPinned bool `json:"is_pinned"`
}
// Changes the pinned state of a chat. There can be up to GetOption("pinned_chat_count_max")/GetOption("pinned_archived_chat_count_max") pinned non-secret chats and the same number of secret chats in the main/archive chat list
func (client *Client) ToggleChatIsPinned(req *ToggleChatIsPinnedRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "toggleChatIsPinned",
},
Data: map[string]interface{}{
"chat_list": req.ChatList,
"chat_id": req.ChatId,
"is_pinned": req.IsPinned,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type SetPinnedChatsRequest struct {
// Chat list in which to change the order of pinned chats
ChatList ChatList `json:"chat_list"`
// The new list of pinned chats
ChatIds []int64 `json:"chat_ids"`
}
// Changes the order of pinned chats
func (client *Client) SetPinnedChats(req *SetPinnedChatsRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "setPinnedChats",
},
Data: map[string]interface{}{
"chat_list": req.ChatList,
"chat_ids": req.ChatIds,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type GetAttachmentMenuBotRequest struct {
// Bot's user identifier
BotUserId int64 `json:"bot_user_id"`
}
// Returns information about a bot that can be added to attachment menu
func (client *Client) GetAttachmentMenuBot(req *GetAttachmentMenuBotRequest) (*AttachmentMenuBot, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getAttachmentMenuBot",
},
Data: map[string]interface{}{
"bot_user_id": req.BotUserId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalAttachmentMenuBot(result.Data)
}
type ToggleBotIsAddedToAttachmentMenuRequest struct {
// Bot's user identifier
BotUserId int64 `json:"bot_user_id"`
// Pass true to add the bot to attachment menu; pass false to remove the bot from attachment menu
IsAdded bool `json:"is_added"`
}
// Adds or removes a bot to attachment menu. Bot can be added to attachment menu, only if userTypeBot.can_be_added_to_attachment_menu == true
func (client *Client) ToggleBotIsAddedToAttachmentMenu(req *ToggleBotIsAddedToAttachmentMenuRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "toggleBotIsAddedToAttachmentMenu",
},
Data: map[string]interface{}{
"bot_user_id": req.BotUserId,
"is_added": req.IsAdded,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type DownloadFileRequest struct {
// Identifier of the file to download
FileId int32 `json:"file_id"`
// Priority of the download (1-32). The higher the priority, the earlier the file will be downloaded. If the priorities of two files are equal, then the last one for which downloadFile/addFileToDownloads was called will be downloaded first
Priority int32 `json:"priority"`
// The starting position from which the file needs to be downloaded
Offset int32 `json:"offset"`
// Number of bytes which need to be downloaded starting from the "offset" position before the download will automatically be canceled; use 0 to download without a limit
Limit int32 `json:"limit"`
// Pass true to return response only after the file download has succeeded, has failed, has been canceled, or a new downloadFile request with different offset/limit parameters was sent; pass false to return file state immediately, just after the download has been started
Synchronous bool `json:"synchronous"`
}
// Downloads a file from the cloud. Download progress and completion of the download will be notified through updateFile updates
func (client *Client) DownloadFile(req *DownloadFileRequest) (*File, error) {
result, err := client.Send(Request{
meta: meta{
Type: "downloadFile",
},
Data: map[string]interface{}{
"file_id": req.FileId,
"priority": req.Priority,
"offset": req.Offset,
"limit": req.Limit,
"synchronous": req.Synchronous,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalFile(result.Data)
}
type GetFileDownloadedPrefixSizeRequest struct {
// Identifier of the file
FileId int32 `json:"file_id"`
// Offset from which downloaded prefix size needs to be calculated
Offset int32 `json:"offset"`
}
// Returns file downloaded prefix size from a given offset, in bytes
func (client *Client) GetFileDownloadedPrefixSize(req *GetFileDownloadedPrefixSizeRequest) (*Count, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getFileDownloadedPrefixSize",
},
Data: map[string]interface{}{
"file_id": req.FileId,
"offset": req.Offset,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalCount(result.Data)
}
type CancelDownloadFileRequest struct {
// Identifier of a file to stop downloading
FileId int32 `json:"file_id"`
// Pass true to stop downloading only if it hasn't been started, i.e. request hasn't been sent to server
OnlyIfPending bool `json:"only_if_pending"`
}
// Stops the downloading of a file. If a file has already been downloaded, does nothing
func (client *Client) CancelDownloadFile(req *CancelDownloadFileRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "cancelDownloadFile",
},
Data: map[string]interface{}{
"file_id": req.FileId,
"only_if_pending": req.OnlyIfPending,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type GetSuggestedFileNameRequest struct {
// Identifier of the file
FileId int32 `json:"file_id"`
// Directory in which the file is supposed to be saved
Directory string `json:"directory"`
}
// Returns suggested name for saving a file in a given directory
func (client *Client) GetSuggestedFileName(req *GetSuggestedFileNameRequest) (*Text, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getSuggestedFileName",
},
Data: map[string]interface{}{
"file_id": req.FileId,
"directory": req.Directory,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalText(result.Data)
}
type UploadFileRequest struct {
// File to upload
File InputFile `json:"file"`
// File type; pass null if unknown
FileType FileType `json:"file_type"`
// Priority of the upload (1-32). The higher the priority, the earlier the file will be uploaded. If the priorities of two files are equal, then the first one for which uploadFile was called will be uploaded first
Priority int32 `json:"priority"`
}
// Asynchronously uploads a file to the cloud without sending it in a message. updateFile will be used to notify about upload progress and successful completion of the upload. The file will not have a persistent remote identifier until it will be sent in a message
func (client *Client) UploadFile(req *UploadFileRequest) (*File, error) {
result, err := client.Send(Request{
meta: meta{
Type: "uploadFile",
},
Data: map[string]interface{}{
"file": req.File,
"file_type": req.FileType,
"priority": req.Priority,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalFile(result.Data)
}
type CancelUploadFileRequest struct {
// Identifier of the file to stop uploading
FileId int32 `json:"file_id"`
}
// Stops the uploading of a file. Supported only for files uploaded by using uploadFile. For other files the behavior is undefined
func (client *Client) CancelUploadFile(req *CancelUploadFileRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "cancelUploadFile",
},
Data: map[string]interface{}{
"file_id": req.FileId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type WriteGeneratedFilePartRequest struct {
// The identifier of the generation process
GenerationId JsonInt64 `json:"generation_id"`
// The offset from which to write the data to the file
Offset int32 `json:"offset"`
// The data to write
Data []byte `json:"data"`
}
// Writes a part of a generated file. This method is intended to be used only if the application has no direct access to TDLib's file system, because it is usually slower than a direct write to the destination file
func (client *Client) WriteGeneratedFilePart(req *WriteGeneratedFilePartRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "writeGeneratedFilePart",
},
Data: map[string]interface{}{
"generation_id": req.GenerationId,
"offset": req.Offset,
"data": req.Data,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type SetFileGenerationProgressRequest struct {
// The identifier of the generation process
GenerationId JsonInt64 `json:"generation_id"`
// Expected size of the generated file, in bytes; 0 if unknown
ExpectedSize int32 `json:"expected_size"`
// The number of bytes already generated
LocalPrefixSize int32 `json:"local_prefix_size"`
}
// Informs TDLib on a file generation progress
func (client *Client) SetFileGenerationProgress(req *SetFileGenerationProgressRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "setFileGenerationProgress",
},
Data: map[string]interface{}{
"generation_id": req.GenerationId,
"expected_size": req.ExpectedSize,
"local_prefix_size": req.LocalPrefixSize,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type FinishFileGenerationRequest struct {
// The identifier of the generation process
GenerationId JsonInt64 `json:"generation_id"`
// If passed, the file generation has failed and must be terminated; pass null if the file generation succeeded
Error *Error `json:"error"`
}
// Finishes the file generation
func (client *Client) FinishFileGeneration(req *FinishFileGenerationRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "finishFileGeneration",
},
Data: map[string]interface{}{
"generation_id": req.GenerationId,
"error": req.Error,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type ReadFilePartRequest struct {
// Identifier of the file. The file must be located in the TDLib file cache
FileId int32 `json:"file_id"`
// The offset from which to read the file
Offset int32 `json:"offset"`
// Number of bytes to read. An error will be returned if there are not enough bytes available in the file from the specified position. Pass 0 to read all available data from the specified position
Count int32 `json:"count"`
}
// Reads a part of a file from the TDLib file cache and returns read bytes. This method is intended to be used only if the application has no direct access to TDLib's file system, because it is usually slower than a direct read from the file
func (client *Client) ReadFilePart(req *ReadFilePartRequest) (*FilePart, error) {
result, err := client.Send(Request{
meta: meta{
Type: "readFilePart",
},
Data: map[string]interface{}{
"file_id": req.FileId,
"offset": req.Offset,
"count": req.Count,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalFilePart(result.Data)
}
type DeleteFileRequest struct {
// Identifier of the file to delete
FileId int32 `json:"file_id"`
}
// Deletes a file from the TDLib file cache
func (client *Client) DeleteFile(req *DeleteFileRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "deleteFile",
},
Data: map[string]interface{}{
"file_id": req.FileId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type AddFileToDownloadsRequest struct {
// Identifier of the file to download
FileId int32 `json:"file_id"`
// Chat identifier of the message with the file
ChatId int64 `json:"chat_id"`
// Message identifier
MessageId int64 `json:"message_id"`
// Priority of the download (1-32). The higher the priority, the earlier the file will be downloaded. If the priorities of two files are equal, then the last one for which downloadFile/addFileToDownloads was called will be downloaded first
Priority int32 `json:"priority"`
}
// Adds a file from a message to the list of file downloads. Download progress and completion of the download will be notified through updateFile updates. If message database is used, the list of file downloads is persistent across application restarts. The downloading is independent from download using downloadFile, i.e. it continues if downloadFile is canceled or is used to download a part of the file
func (client *Client) AddFileToDownloads(req *AddFileToDownloadsRequest) (*File, error) {
result, err := client.Send(Request{
meta: meta{
Type: "addFileToDownloads",
},
Data: map[string]interface{}{
"file_id": req.FileId,
"chat_id": req.ChatId,
"message_id": req.MessageId,
"priority": req.Priority,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalFile(result.Data)
}
type ToggleDownloadIsPausedRequest struct {
// Identifier of the downloaded file
FileId int32 `json:"file_id"`
// Pass true if the download is paused
IsPaused bool `json:"is_paused"`
}
// Changes pause state of a file in the file download list
func (client *Client) ToggleDownloadIsPaused(req *ToggleDownloadIsPausedRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "toggleDownloadIsPaused",
},
Data: map[string]interface{}{
"file_id": req.FileId,
"is_paused": req.IsPaused,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type ToggleAllDownloadsArePausedRequest struct {
// Pass true to pause all downloads; pass false to unpause them
ArePaused bool `json:"are_paused"`
}
// Changes pause state of all files in the file download list
func (client *Client) ToggleAllDownloadsArePaused(req *ToggleAllDownloadsArePausedRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "toggleAllDownloadsArePaused",
},
Data: map[string]interface{}{
"are_paused": req.ArePaused,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type RemoveFileFromDownloadsRequest struct {
// Identifier of the downloaded file
FileId int32 `json:"file_id"`
// Pass true to delete the file from the TDLib file cache
DeleteFromCache bool `json:"delete_from_cache"`
}
// Removes a file from the file download list
func (client *Client) RemoveFileFromDownloads(req *RemoveFileFromDownloadsRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "removeFileFromDownloads",
},
Data: map[string]interface{}{
"file_id": req.FileId,
"delete_from_cache": req.DeleteFromCache,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type RemoveAllFilesFromDownloadsRequest struct {
// Pass true to remove only active downloads, including paused
OnlyActive bool `json:"only_active"`
// Pass true to remove only completed downloads
OnlyCompleted bool `json:"only_completed"`
// Pass true to delete the file from the TDLib file cache
DeleteFromCache bool `json:"delete_from_cache"`
}
// Removes all files from the file download list
func (client *Client) RemoveAllFilesFromDownloads(req *RemoveAllFilesFromDownloadsRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "removeAllFilesFromDownloads",
},
Data: map[string]interface{}{
"only_active": req.OnlyActive,
"only_completed": req.OnlyCompleted,
"delete_from_cache": req.DeleteFromCache,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type SearchFileDownloadsRequest struct {
// Query to search for; may be empty to return all downloaded files
Query string `json:"query"`
// Pass true to search only for active downloads, including paused
OnlyActive bool `json:"only_active"`
// Pass true to search only for completed downloads
OnlyCompleted bool `json:"only_completed"`
// Offset of the first entry to return as received from the previous request; use empty string to get the first chunk of results
Offset string `json:"offset"`
// The maximum number of files to be returned
Limit int32 `json:"limit"`
}
// Searches for files in the file download list or recently downloaded files from the list
func (client *Client) SearchFileDownloads(req *SearchFileDownloadsRequest) (*FoundFileDownloads, error) {
result, err := client.Send(Request{
meta: meta{
Type: "searchFileDownloads",
},
Data: map[string]interface{}{
"query": req.Query,
"only_active": req.OnlyActive,
"only_completed": req.OnlyCompleted,
"offset": req.Offset,
"limit": req.Limit,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalFoundFileDownloads(result.Data)
}
type GetMessageFileTypeRequest struct {
// Beginning of the message file; up to 100 first lines
MessageFileHead string `json:"message_file_head"`
}
// Returns information about a file with messages exported from another app
func (client *Client) GetMessageFileType(req *GetMessageFileTypeRequest) (MessageFileType, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getMessageFileType",
},
Data: map[string]interface{}{
"message_file_head": req.MessageFileHead,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
switch result.Type {
case TypeMessageFileTypePrivate:
return UnmarshalMessageFileTypePrivate(result.Data)
case TypeMessageFileTypeGroup:
return UnmarshalMessageFileTypeGroup(result.Data)
case TypeMessageFileTypeUnknown:
return UnmarshalMessageFileTypeUnknown(result.Data)
default:
return nil, errors.New("invalid type")
}
}
type GetMessageImportConfirmationTextRequest struct {
// Identifier of a chat to which the messages will be imported. It must be an identifier of a private chat with a mutual contact or an identifier of a supergroup chat with can_change_info administrator right
ChatId int64 `json:"chat_id"`
}
// Returns a confirmation text to be shown to the user before starting message import
func (client *Client) GetMessageImportConfirmationText(req *GetMessageImportConfirmationTextRequest) (*Text, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getMessageImportConfirmationText",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalText(result.Data)
}
type ImportMessagesRequest struct {
// Identifier of a chat to which the messages will be imported. It must be an identifier of a private chat with a mutual contact or an identifier of a supergroup chat with can_change_info administrator right
ChatId int64 `json:"chat_id"`
// File with messages to import. Only inputFileLocal and inputFileGenerated are supported. The file must not be previously uploaded
MessageFile InputFile `json:"message_file"`
// Files used in the imported messages. Only inputFileLocal and inputFileGenerated are supported. The files must not be previously uploaded
AttachedFiles []InputFile `json:"attached_files"`
}
// Imports messages exported from another app
func (client *Client) ImportMessages(req *ImportMessagesRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "importMessages",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"message_file": req.MessageFile,
"attached_files": req.AttachedFiles,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type ReplacePrimaryChatInviteLinkRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
}
// Replaces current primary invite link for a chat with a new primary invite link. Available for basic groups, supergroups, and channels. Requires administrator privileges and can_invite_users right
func (client *Client) ReplacePrimaryChatInviteLink(req *ReplacePrimaryChatInviteLinkRequest) (*ChatInviteLink, error) {
result, err := client.Send(Request{
meta: meta{
Type: "replacePrimaryChatInviteLink",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalChatInviteLink(result.Data)
}
type CreateChatInviteLinkRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
// Invite link name; 0-32 characters
Name string `json:"name"`
// Point in time (Unix timestamp) when the link will expire; pass 0 if never
ExpirationDate int32 `json:"expiration_date"`
// The maximum number of chat members that can join the chat via the link simultaneously; 0-99999; pass 0 if not limited
MemberLimit int32 `json:"member_limit"`
// Pass true if users joining the chat via the link need to be approved by chat administrators. In this case, member_limit must be 0
CreatesJoinRequest bool `json:"creates_join_request"`
}
// Creates a new invite link for a chat. Available for basic groups, supergroups, and channels. Requires administrator privileges and can_invite_users right in the chat
func (client *Client) CreateChatInviteLink(req *CreateChatInviteLinkRequest) (*ChatInviteLink, error) {
result, err := client.Send(Request{
meta: meta{
Type: "createChatInviteLink",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"name": req.Name,
"expiration_date": req.ExpirationDate,
"member_limit": req.MemberLimit,
"creates_join_request": req.CreatesJoinRequest,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalChatInviteLink(result.Data)
}
type EditChatInviteLinkRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
// Invite link to be edited
InviteLink string `json:"invite_link"`
// Invite link name; 0-32 characters
Name string `json:"name"`
// Point in time (Unix timestamp) when the link will expire; pass 0 if never
ExpirationDate int32 `json:"expiration_date"`
// The maximum number of chat members that can join the chat via the link simultaneously; 0-99999; pass 0 if not limited
MemberLimit int32 `json:"member_limit"`
// Pass true if users joining the chat via the link need to be approved by chat administrators. In this case, member_limit must be 0
CreatesJoinRequest bool `json:"creates_join_request"`
}
// Edits a non-primary invite link for a chat. Available for basic groups, supergroups, and channels. Requires administrator privileges and can_invite_users right in the chat for own links and owner privileges for other links
func (client *Client) EditChatInviteLink(req *EditChatInviteLinkRequest) (*ChatInviteLink, error) {
result, err := client.Send(Request{
meta: meta{
Type: "editChatInviteLink",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"invite_link": req.InviteLink,
"name": req.Name,
"expiration_date": req.ExpirationDate,
"member_limit": req.MemberLimit,
"creates_join_request": req.CreatesJoinRequest,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalChatInviteLink(result.Data)
}
type GetChatInviteLinkRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
// Invite link to get
InviteLink string `json:"invite_link"`
}
// Returns information about an invite link. Requires administrator privileges and can_invite_users right in the chat to get own links and owner privileges to get other links
func (client *Client) GetChatInviteLink(req *GetChatInviteLinkRequest) (*ChatInviteLink, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getChatInviteLink",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"invite_link": req.InviteLink,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalChatInviteLink(result.Data)
}
type GetChatInviteLinkCountsRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
}
// Returns list of chat administrators with number of their invite links. Requires owner privileges in the chat
func (client *Client) GetChatInviteLinkCounts(req *GetChatInviteLinkCountsRequest) (*ChatInviteLinkCounts, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getChatInviteLinkCounts",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalChatInviteLinkCounts(result.Data)
}
type GetChatInviteLinksRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
// User identifier of a chat administrator. Must be an identifier of the current user for non-owner
CreatorUserId int64 `json:"creator_user_id"`
// Pass true if revoked links needs to be returned instead of active or expired
IsRevoked bool `json:"is_revoked"`
// Creation date of an invite link starting after which to return invite links; use 0 to get results from the beginning
OffsetDate int32 `json:"offset_date"`
// Invite link starting after which to return invite links; use empty string to get results from the beginning
OffsetInviteLink string `json:"offset_invite_link"`
// The maximum number of invite links to return; up to 100
Limit int32 `json:"limit"`
}
// Returns invite links for a chat created by specified administrator. Requires administrator privileges and can_invite_users right in the chat to get own links and owner privileges to get other links
func (client *Client) GetChatInviteLinks(req *GetChatInviteLinksRequest) (*ChatInviteLinks, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getChatInviteLinks",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"creator_user_id": req.CreatorUserId,
"is_revoked": req.IsRevoked,
"offset_date": req.OffsetDate,
"offset_invite_link": req.OffsetInviteLink,
"limit": req.Limit,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalChatInviteLinks(result.Data)
}
type GetChatInviteLinkMembersRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
// Invite link for which to return chat members
InviteLink string `json:"invite_link"`
// A chat member from which to return next chat members; pass null to get results from the beginning
OffsetMember *ChatInviteLinkMember `json:"offset_member"`
// The maximum number of chat members to return; up to 100
Limit int32 `json:"limit"`
}
// Returns chat members joined a chat via an invite link. Requires administrator privileges and can_invite_users right in the chat for own links and owner privileges for other links
func (client *Client) GetChatInviteLinkMembers(req *GetChatInviteLinkMembersRequest) (*ChatInviteLinkMembers, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getChatInviteLinkMembers",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"invite_link": req.InviteLink,
"offset_member": req.OffsetMember,
"limit": req.Limit,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalChatInviteLinkMembers(result.Data)
}
type RevokeChatInviteLinkRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
// Invite link to be revoked
InviteLink string `json:"invite_link"`
}
// Revokes invite link for a chat. Available for basic groups, supergroups, and channels. Requires administrator privileges and can_invite_users right in the chat for own links and owner privileges for other links. If a primary link is revoked, then additionally to the revoked link returns new primary link
func (client *Client) RevokeChatInviteLink(req *RevokeChatInviteLinkRequest) (*ChatInviteLinks, error) {
result, err := client.Send(Request{
meta: meta{
Type: "revokeChatInviteLink",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"invite_link": req.InviteLink,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalChatInviteLinks(result.Data)
}
type DeleteRevokedChatInviteLinkRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
// Invite link to revoke
InviteLink string `json:"invite_link"`
}
// Deletes revoked chat invite links. Requires administrator privileges and can_invite_users right in the chat for own links and owner privileges for other links
func (client *Client) DeleteRevokedChatInviteLink(req *DeleteRevokedChatInviteLinkRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "deleteRevokedChatInviteLink",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"invite_link": req.InviteLink,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type DeleteAllRevokedChatInviteLinksRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
// User identifier of a chat administrator, which links will be deleted. Must be an identifier of the current user for non-owner
CreatorUserId int64 `json:"creator_user_id"`
}
// Deletes all revoked chat invite links created by a given chat administrator. Requires administrator privileges and can_invite_users right in the chat for own links and owner privileges for other links
func (client *Client) DeleteAllRevokedChatInviteLinks(req *DeleteAllRevokedChatInviteLinksRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "deleteAllRevokedChatInviteLinks",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"creator_user_id": req.CreatorUserId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type CheckChatInviteLinkRequest struct {
// Invite link to be checked
InviteLink string `json:"invite_link"`
}
// Checks the validity of an invite link for a chat and returns information about the corresponding chat
func (client *Client) CheckChatInviteLink(req *CheckChatInviteLinkRequest) (*ChatInviteLinkInfo, error) {
result, err := client.Send(Request{
meta: meta{
Type: "checkChatInviteLink",
},
Data: map[string]interface{}{
"invite_link": req.InviteLink,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalChatInviteLinkInfo(result.Data)
}
type JoinChatByInviteLinkRequest struct {
// Invite link to use
InviteLink string `json:"invite_link"`
}
// Uses an invite link to add the current user to the chat if possible
func (client *Client) JoinChatByInviteLink(req *JoinChatByInviteLinkRequest) (*Chat, error) {
result, err := client.Send(Request{
meta: meta{
Type: "joinChatByInviteLink",
},
Data: map[string]interface{}{
"invite_link": req.InviteLink,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalChat(result.Data)
}
type GetChatJoinRequestsRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
// Invite link for which to return join requests. If empty, all join requests will be returned. Requires administrator privileges and can_invite_users right in the chat for own links and owner privileges for other links
InviteLink string `json:"invite_link"`
// A query to search for in the first names, last names and usernames of the users to return
Query string `json:"query"`
// A chat join request from which to return next requests; pass null to get results from the beginning
OffsetRequest *ChatJoinRequest `json:"offset_request"`
// The maximum number of requests to join the chat to return
Limit int32 `json:"limit"`
}
// Returns pending join requests in a chat
func (client *Client) GetChatJoinRequests(req *GetChatJoinRequestsRequest) (*ChatJoinRequests, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getChatJoinRequests",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"invite_link": req.InviteLink,
"query": req.Query,
"offset_request": req.OffsetRequest,
"limit": req.Limit,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalChatJoinRequests(result.Data)
}
type ProcessChatJoinRequestRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
// Identifier of the user that sent the request
UserId int64 `json:"user_id"`
// Pass true to approve the request; pass false to decline it
Approve bool `json:"approve"`
}
// Handles a pending join request in a chat
func (client *Client) ProcessChatJoinRequest(req *ProcessChatJoinRequestRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "processChatJoinRequest",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"user_id": req.UserId,
"approve": req.Approve,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type ProcessChatJoinRequestsRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
// Invite link for which to process join requests. If empty, all join requests will be processed. Requires administrator privileges and can_invite_users right in the chat for own links and owner privileges for other links
InviteLink string `json:"invite_link"`
// Pass true to approve all requests; pass false to decline them
Approve bool `json:"approve"`
}
// Handles all pending join requests for a given link in a chat
func (client *Client) ProcessChatJoinRequests(req *ProcessChatJoinRequestsRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "processChatJoinRequests",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"invite_link": req.InviteLink,
"approve": req.Approve,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type CreateCallRequest struct {
// Identifier of the user to be called
UserId int64 `json:"user_id"`
// The call protocols supported by the application
Protocol *CallProtocol `json:"protocol"`
// Pass true to create a video call
IsVideo bool `json:"is_video"`
}
// Creates a new call
func (client *Client) CreateCall(req *CreateCallRequest) (*CallId, error) {
result, err := client.Send(Request{
meta: meta{
Type: "createCall",
},
Data: map[string]interface{}{
"user_id": req.UserId,
"protocol": req.Protocol,
"is_video": req.IsVideo,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalCallId(result.Data)
}
type AcceptCallRequest struct {
// Call identifier
CallId int32 `json:"call_id"`
// The call protocols supported by the application
Protocol *CallProtocol `json:"protocol"`
}
// Accepts an incoming call
func (client *Client) AcceptCall(req *AcceptCallRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "acceptCall",
},
Data: map[string]interface{}{
"call_id": req.CallId,
"protocol": req.Protocol,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type SendCallSignalingDataRequest struct {
// Call identifier
CallId int32 `json:"call_id"`
// The data
Data []byte `json:"data"`
}
// Sends call signaling data
func (client *Client) SendCallSignalingData(req *SendCallSignalingDataRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "sendCallSignalingData",
},
Data: map[string]interface{}{
"call_id": req.CallId,
"data": req.Data,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type DiscardCallRequest struct {
// Call identifier
CallId int32 `json:"call_id"`
// Pass true if the user was disconnected
IsDisconnected bool `json:"is_disconnected"`
// The call duration, in seconds
Duration int32 `json:"duration"`
// Pass true if the call was a video call
IsVideo bool `json:"is_video"`
// Identifier of the connection used during the call
ConnectionId JsonInt64 `json:"connection_id"`
}
// Discards a call
func (client *Client) DiscardCall(req *DiscardCallRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "discardCall",
},
Data: map[string]interface{}{
"call_id": req.CallId,
"is_disconnected": req.IsDisconnected,
"duration": req.Duration,
"is_video": req.IsVideo,
"connection_id": req.ConnectionId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type SendCallRatingRequest struct {
// Call identifier
CallId int32 `json:"call_id"`
// Call rating; 1-5
Rating int32 `json:"rating"`
// An optional user comment if the rating is less than 5
Comment string `json:"comment"`
// List of the exact types of problems with the call, specified by the user
Problems []CallProblem `json:"problems"`
}
// Sends a call rating
func (client *Client) SendCallRating(req *SendCallRatingRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "sendCallRating",
},
Data: map[string]interface{}{
"call_id": req.CallId,
"rating": req.Rating,
"comment": req.Comment,
"problems": req.Problems,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type SendCallDebugInformationRequest struct {
// Call identifier
CallId int32 `json:"call_id"`
// Debug information in application-specific format
DebugInformation string `json:"debug_information"`
}
// Sends debug information for a call to Telegram servers
func (client *Client) SendCallDebugInformation(req *SendCallDebugInformationRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "sendCallDebugInformation",
},
Data: map[string]interface{}{
"call_id": req.CallId,
"debug_information": req.DebugInformation,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type SendCallLogRequest struct {
// Call identifier
CallId int32 `json:"call_id"`
// Call log file. Only inputFileLocal and inputFileGenerated are supported
LogFile InputFile `json:"log_file"`
}
// Sends log file for a call to Telegram servers
func (client *Client) SendCallLog(req *SendCallLogRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "sendCallLog",
},
Data: map[string]interface{}{
"call_id": req.CallId,
"log_file": req.LogFile,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type GetVideoChatAvailableParticipantsRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
}
// Returns list of participant identifiers, on whose behalf a video chat in the chat can be joined
func (client *Client) GetVideoChatAvailableParticipants(req *GetVideoChatAvailableParticipantsRequest) (*MessageSenders, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getVideoChatAvailableParticipants",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalMessageSenders(result.Data)
}
type SetVideoChatDefaultParticipantRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
// Default group call participant identifier to join the video chats
DefaultParticipantId MessageSender `json:"default_participant_id"`
}
// Changes default participant identifier, on whose behalf a video chat in the chat will be joined
func (client *Client) SetVideoChatDefaultParticipant(req *SetVideoChatDefaultParticipantRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "setVideoChatDefaultParticipant",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"default_participant_id": req.DefaultParticipantId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type CreateVideoChatRequest struct {
// Identifier of a chat in which the video chat will be created
ChatId int64 `json:"chat_id"`
// Group call title; if empty, chat title will be used
Title string `json:"title"`
// Point in time (Unix timestamp) when the group call is supposed to be started by an administrator; 0 to start the video chat immediately. The date must be at least 10 seconds and at most 8 days in the future
StartDate int32 `json:"start_date"`
// Pass true to create an RTMP stream instead of an ordinary video chat; requires creator privileges
IsRtmpStream bool `json:"is_rtmp_stream"`
}
// Creates a video chat (a group call bound to a chat). Available only for basic groups, supergroups and channels; requires can_manage_video_chats rights
func (client *Client) CreateVideoChat(req *CreateVideoChatRequest) (*GroupCallId, error) {
result, err := client.Send(Request{
meta: meta{
Type: "createVideoChat",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"title": req.Title,
"start_date": req.StartDate,
"is_rtmp_stream": req.IsRtmpStream,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalGroupCallId(result.Data)
}
type GetVideoChatRtmpUrlRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
}
// Returns RTMP URL for streaming to the chat; requires creator privileges
func (client *Client) GetVideoChatRtmpUrl(req *GetVideoChatRtmpUrlRequest) (*RtmpUrl, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getVideoChatRtmpUrl",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalRtmpUrl(result.Data)
}
type ReplaceVideoChatRtmpUrlRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
}
// Replaces the current RTMP URL for streaming to the chat; requires creator privileges
func (client *Client) ReplaceVideoChatRtmpUrl(req *ReplaceVideoChatRtmpUrlRequest) (*RtmpUrl, error) {
result, err := client.Send(Request{
meta: meta{
Type: "replaceVideoChatRtmpUrl",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalRtmpUrl(result.Data)
}
type GetGroupCallRequest struct {
// Group call identifier
GroupCallId int32 `json:"group_call_id"`
}
// Returns information about a group call
func (client *Client) GetGroupCall(req *GetGroupCallRequest) (*GroupCall, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getGroupCall",
},
Data: map[string]interface{}{
"group_call_id": req.GroupCallId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalGroupCall(result.Data)
}
type StartScheduledGroupCallRequest struct {
// Group call identifier
GroupCallId int32 `json:"group_call_id"`
}
// Starts a scheduled group call
func (client *Client) StartScheduledGroupCall(req *StartScheduledGroupCallRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "startScheduledGroupCall",
},
Data: map[string]interface{}{
"group_call_id": req.GroupCallId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type ToggleGroupCallEnabledStartNotificationRequest struct {
// Group call identifier
GroupCallId int32 `json:"group_call_id"`
// New value of the enabled_start_notification setting
EnabledStartNotification bool `json:"enabled_start_notification"`
}
// Toggles whether the current user will receive a notification when the group call will start; scheduled group calls only
func (client *Client) ToggleGroupCallEnabledStartNotification(req *ToggleGroupCallEnabledStartNotificationRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "toggleGroupCallEnabledStartNotification",
},
Data: map[string]interface{}{
"group_call_id": req.GroupCallId,
"enabled_start_notification": req.EnabledStartNotification,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type JoinGroupCallRequest struct {
// Group call identifier
GroupCallId int32 `json:"group_call_id"`
// Identifier of a group call participant, which will be used to join the call; pass null to join as self; video chats only
ParticipantId MessageSender `json:"participant_id"`
// Caller audio channel synchronization source identifier; received from tgcalls
AudioSourceId int32 `json:"audio_source_id"`
// Group call join payload; received from tgcalls
Payload string `json:"payload"`
// Pass true to join the call with muted microphone
IsMuted bool `json:"is_muted"`
// Pass true if the user's video is enabled
IsMyVideoEnabled bool `json:"is_my_video_enabled"`
// If non-empty, invite hash to be used to join the group call without being muted by administrators
InviteHash string `json:"invite_hash"`
}
// Joins an active group call. Returns join response payload for tgcalls
func (client *Client) JoinGroupCall(req *JoinGroupCallRequest) (*Text, error) {
result, err := client.Send(Request{
meta: meta{
Type: "joinGroupCall",
},
Data: map[string]interface{}{
"group_call_id": req.GroupCallId,
"participant_id": req.ParticipantId,
"audio_source_id": req.AudioSourceId,
"payload": req.Payload,
"is_muted": req.IsMuted,
"is_my_video_enabled": req.IsMyVideoEnabled,
"invite_hash": req.InviteHash,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalText(result.Data)
}
type StartGroupCallScreenSharingRequest struct {
// Group call identifier
GroupCallId int32 `json:"group_call_id"`
// Screen sharing audio channel synchronization source identifier; received from tgcalls
AudioSourceId int32 `json:"audio_source_id"`
// Group call join payload; received from tgcalls
Payload string `json:"payload"`
}
// Starts screen sharing in a joined group call. Returns join response payload for tgcalls
func (client *Client) StartGroupCallScreenSharing(req *StartGroupCallScreenSharingRequest) (*Text, error) {
result, err := client.Send(Request{
meta: meta{
Type: "startGroupCallScreenSharing",
},
Data: map[string]interface{}{
"group_call_id": req.GroupCallId,
"audio_source_id": req.AudioSourceId,
"payload": req.Payload,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalText(result.Data)
}
type ToggleGroupCallScreenSharingIsPausedRequest struct {
// Group call identifier
GroupCallId int32 `json:"group_call_id"`
// True if screen sharing is paused
IsPaused bool `json:"is_paused"`
}
// Pauses or unpauses screen sharing in a joined group call
func (client *Client) ToggleGroupCallScreenSharingIsPaused(req *ToggleGroupCallScreenSharingIsPausedRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "toggleGroupCallScreenSharingIsPaused",
},
Data: map[string]interface{}{
"group_call_id": req.GroupCallId,
"is_paused": req.IsPaused,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type EndGroupCallScreenSharingRequest struct {
// Group call identifier
GroupCallId int32 `json:"group_call_id"`
}
// Ends screen sharing in a joined group call
func (client *Client) EndGroupCallScreenSharing(req *EndGroupCallScreenSharingRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "endGroupCallScreenSharing",
},
Data: map[string]interface{}{
"group_call_id": req.GroupCallId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type SetGroupCallTitleRequest struct {
// Group call identifier
GroupCallId int32 `json:"group_call_id"`
// New group call title; 1-64 characters
Title string `json:"title"`
}
// Sets group call title. Requires groupCall.can_be_managed group call flag
func (client *Client) SetGroupCallTitle(req *SetGroupCallTitleRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "setGroupCallTitle",
},
Data: map[string]interface{}{
"group_call_id": req.GroupCallId,
"title": req.Title,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type ToggleGroupCallMuteNewParticipantsRequest struct {
// Group call identifier
GroupCallId int32 `json:"group_call_id"`
// New value of the mute_new_participants setting
MuteNewParticipants bool `json:"mute_new_participants"`
}
// Toggles whether new participants of a group call can be unmuted only by administrators of the group call. Requires groupCall.can_toggle_mute_new_participants group call flag
func (client *Client) ToggleGroupCallMuteNewParticipants(req *ToggleGroupCallMuteNewParticipantsRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "toggleGroupCallMuteNewParticipants",
},
Data: map[string]interface{}{
"group_call_id": req.GroupCallId,
"mute_new_participants": req.MuteNewParticipants,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type InviteGroupCallParticipantsRequest struct {
// Group call identifier
GroupCallId int32 `json:"group_call_id"`
// User identifiers. At most 10 users can be invited simultaneously
UserIds []int64 `json:"user_ids"`
}
// Invites users to an active group call. Sends a service message of type messageInviteToGroupCall for video chats
func (client *Client) InviteGroupCallParticipants(req *InviteGroupCallParticipantsRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "inviteGroupCallParticipants",
},
Data: map[string]interface{}{
"group_call_id": req.GroupCallId,
"user_ids": req.UserIds,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type GetGroupCallInviteLinkRequest struct {
// Group call identifier
GroupCallId int32 `json:"group_call_id"`
// Pass true if the invite link needs to contain an invite hash, passing which to joinGroupCall would allow the invited user to unmute themselves. Requires groupCall.can_be_managed group call flag
CanSelfUnmute bool `json:"can_self_unmute"`
}
// Returns invite link to a video chat in a public chat
func (client *Client) GetGroupCallInviteLink(req *GetGroupCallInviteLinkRequest) (*HttpUrl, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getGroupCallInviteLink",
},
Data: map[string]interface{}{
"group_call_id": req.GroupCallId,
"can_self_unmute": req.CanSelfUnmute,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalHttpUrl(result.Data)
}
type RevokeGroupCallInviteLinkRequest struct {
// Group call identifier
GroupCallId int32 `json:"group_call_id"`
}
// Revokes invite link for a group call. Requires groupCall.can_be_managed group call flag
func (client *Client) RevokeGroupCallInviteLink(req *RevokeGroupCallInviteLinkRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "revokeGroupCallInviteLink",
},
Data: map[string]interface{}{
"group_call_id": req.GroupCallId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type StartGroupCallRecordingRequest struct {
// Group call identifier
GroupCallId int32 `json:"group_call_id"`
// Group call recording title; 0-64 characters
Title string `json:"title"`
// Pass true to record a video file instead of an audio file
RecordVideo bool `json:"record_video"`
// Pass true to use portrait orientation for video instead of landscape one
UsePortraitOrientation bool `json:"use_portrait_orientation"`
}
// Starts recording of an active group call. Requires groupCall.can_be_managed group call flag
func (client *Client) StartGroupCallRecording(req *StartGroupCallRecordingRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "startGroupCallRecording",
},
Data: map[string]interface{}{
"group_call_id": req.GroupCallId,
"title": req.Title,
"record_video": req.RecordVideo,
"use_portrait_orientation": req.UsePortraitOrientation,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type EndGroupCallRecordingRequest struct {
// Group call identifier
GroupCallId int32 `json:"group_call_id"`
}
// Ends recording of an active group call. Requires groupCall.can_be_managed group call flag
func (client *Client) EndGroupCallRecording(req *EndGroupCallRecordingRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "endGroupCallRecording",
},
Data: map[string]interface{}{
"group_call_id": req.GroupCallId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type ToggleGroupCallIsMyVideoPausedRequest struct {
// Group call identifier
GroupCallId int32 `json:"group_call_id"`
// Pass true if the current user's video is paused
IsMyVideoPaused bool `json:"is_my_video_paused"`
}
// Toggles whether current user's video is paused
func (client *Client) ToggleGroupCallIsMyVideoPaused(req *ToggleGroupCallIsMyVideoPausedRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "toggleGroupCallIsMyVideoPaused",
},
Data: map[string]interface{}{
"group_call_id": req.GroupCallId,
"is_my_video_paused": req.IsMyVideoPaused,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type ToggleGroupCallIsMyVideoEnabledRequest struct {
// Group call identifier
GroupCallId int32 `json:"group_call_id"`
// Pass true if the current user's video is enabled
IsMyVideoEnabled bool `json:"is_my_video_enabled"`
}
// Toggles whether current user's video is enabled
func (client *Client) ToggleGroupCallIsMyVideoEnabled(req *ToggleGroupCallIsMyVideoEnabledRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "toggleGroupCallIsMyVideoEnabled",
},
Data: map[string]interface{}{
"group_call_id": req.GroupCallId,
"is_my_video_enabled": req.IsMyVideoEnabled,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type SetGroupCallParticipantIsSpeakingRequest struct {
// Group call identifier
GroupCallId int32 `json:"group_call_id"`
// Group call participant's synchronization audio source identifier, or 0 for the current user
AudioSource int32 `json:"audio_source"`
// Pass true if the user is speaking
IsSpeaking bool `json:"is_speaking"`
}
// Informs TDLib that speaking state of a participant of an active group has changed
func (client *Client) SetGroupCallParticipantIsSpeaking(req *SetGroupCallParticipantIsSpeakingRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "setGroupCallParticipantIsSpeaking",
},
Data: map[string]interface{}{
"group_call_id": req.GroupCallId,
"audio_source": req.AudioSource,
"is_speaking": req.IsSpeaking,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type ToggleGroupCallParticipantIsMutedRequest struct {
// Group call identifier
GroupCallId int32 `json:"group_call_id"`
// Participant identifier
ParticipantId MessageSender `json:"participant_id"`
// Pass true to mute the user; pass false to unmute the them
IsMuted bool `json:"is_muted"`
}
// Toggles whether a participant of an active group call is muted, unmuted, or allowed to unmute themselves
func (client *Client) ToggleGroupCallParticipantIsMuted(req *ToggleGroupCallParticipantIsMutedRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "toggleGroupCallParticipantIsMuted",
},
Data: map[string]interface{}{
"group_call_id": req.GroupCallId,
"participant_id": req.ParticipantId,
"is_muted": req.IsMuted,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type SetGroupCallParticipantVolumeLevelRequest struct {
// Group call identifier
GroupCallId int32 `json:"group_call_id"`
// Participant identifier
ParticipantId MessageSender `json:"participant_id"`
// New participant's volume level; 1-20000 in hundreds of percents
VolumeLevel int32 `json:"volume_level"`
}
// Changes volume level of a participant of an active group call. If the current user can manage the group call, then the participant's volume level will be changed for all users with the default volume level
func (client *Client) SetGroupCallParticipantVolumeLevel(req *SetGroupCallParticipantVolumeLevelRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "setGroupCallParticipantVolumeLevel",
},
Data: map[string]interface{}{
"group_call_id": req.GroupCallId,
"participant_id": req.ParticipantId,
"volume_level": req.VolumeLevel,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type ToggleGroupCallParticipantIsHandRaisedRequest struct {
// Group call identifier
GroupCallId int32 `json:"group_call_id"`
// Participant identifier
ParticipantId MessageSender `json:"participant_id"`
// Pass true if the user's hand needs to be raised. Only self hand can be raised. Requires groupCall.can_be_managed group call flag to lower other's hand
IsHandRaised bool `json:"is_hand_raised"`
}
// Toggles whether a group call participant hand is rased
func (client *Client) ToggleGroupCallParticipantIsHandRaised(req *ToggleGroupCallParticipantIsHandRaisedRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "toggleGroupCallParticipantIsHandRaised",
},
Data: map[string]interface{}{
"group_call_id": req.GroupCallId,
"participant_id": req.ParticipantId,
"is_hand_raised": req.IsHandRaised,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type LoadGroupCallParticipantsRequest struct {
// Group call identifier. The group call must be previously received through getGroupCall and must be joined or being joined
GroupCallId int32 `json:"group_call_id"`
// The maximum number of participants to load; up to 100
Limit int32 `json:"limit"`
}
// Loads more participants of a group call. The loaded participants will be received through updates. Use the field groupCall.loaded_all_participants to check whether all participants have already been loaded
func (client *Client) LoadGroupCallParticipants(req *LoadGroupCallParticipantsRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "loadGroupCallParticipants",
},
Data: map[string]interface{}{
"group_call_id": req.GroupCallId,
"limit": req.Limit,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type LeaveGroupCallRequest struct {
// Group call identifier
GroupCallId int32 `json:"group_call_id"`
}
// Leaves a group call
func (client *Client) LeaveGroupCall(req *LeaveGroupCallRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "leaveGroupCall",
},
Data: map[string]interface{}{
"group_call_id": req.GroupCallId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type EndGroupCallRequest struct {
// Group call identifier
GroupCallId int32 `json:"group_call_id"`
}
// Ends a group call. Requires groupCall.can_be_managed
func (client *Client) EndGroupCall(req *EndGroupCallRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "endGroupCall",
},
Data: map[string]interface{}{
"group_call_id": req.GroupCallId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type GetGroupCallStreamsRequest struct {
// Group call identifier
GroupCallId int32 `json:"group_call_id"`
}
// Returns information about available group call streams
func (client *Client) GetGroupCallStreams(req *GetGroupCallStreamsRequest) (*GroupCallStreams, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getGroupCallStreams",
},
Data: map[string]interface{}{
"group_call_id": req.GroupCallId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalGroupCallStreams(result.Data)
}
type GetGroupCallStreamSegmentRequest struct {
// Group call identifier
GroupCallId int32 `json:"group_call_id"`
// Point in time when the stream segment begins; Unix timestamp in milliseconds
TimeOffset int64 `json:"time_offset"`
// Segment duration scale; 0-1. Segment's duration is 1000/(2**scale) milliseconds
Scale int32 `json:"scale"`
// Identifier of an audio/video channel to get as received from tgcalls
ChannelId int32 `json:"channel_id"`
// Video quality as received from tgcalls; pass null to get the worst available quality
VideoQuality GroupCallVideoQuality `json:"video_quality"`
}
// Returns a file with a segment of a group call stream in a modified OGG format for audio or MPEG-4 format for video
func (client *Client) GetGroupCallStreamSegment(req *GetGroupCallStreamSegmentRequest) (*FilePart, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getGroupCallStreamSegment",
},
Data: map[string]interface{}{
"group_call_id": req.GroupCallId,
"time_offset": req.TimeOffset,
"scale": req.Scale,
"channel_id": req.ChannelId,
"video_quality": req.VideoQuality,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalFilePart(result.Data)
}
type ToggleMessageSenderIsBlockedRequest struct {
// Identifier of a message sender to block/unblock
SenderId MessageSender `json:"sender_id"`
// New value of is_blocked
IsBlocked bool `json:"is_blocked"`
}
// Changes the block state of a message sender. Currently, only users and supergroup chats can be blocked
func (client *Client) ToggleMessageSenderIsBlocked(req *ToggleMessageSenderIsBlockedRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "toggleMessageSenderIsBlocked",
},
Data: map[string]interface{}{
"sender_id": req.SenderId,
"is_blocked": req.IsBlocked,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type BlockMessageSenderFromRepliesRequest struct {
// The identifier of an incoming message in the Replies chat
MessageId int64 `json:"message_id"`
// Pass true to delete the message
DeleteMessage bool `json:"delete_message"`
// Pass true to delete all messages from the same sender
DeleteAllMessages bool `json:"delete_all_messages"`
// Pass true to report the sender to the Telegram moderators
ReportSpam bool `json:"report_spam"`
}
// Blocks an original sender of a message in the Replies chat
func (client *Client) BlockMessageSenderFromReplies(req *BlockMessageSenderFromRepliesRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "blockMessageSenderFromReplies",
},
Data: map[string]interface{}{
"message_id": req.MessageId,
"delete_message": req.DeleteMessage,
"delete_all_messages": req.DeleteAllMessages,
"report_spam": req.ReportSpam,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type GetBlockedMessageSendersRequest struct {
// Number of users and chats to skip in the result; must be non-negative
Offset int32 `json:"offset"`
// The maximum number of users and chats to return; up to 100
Limit int32 `json:"limit"`
}
// Returns users and chats that were blocked by the current user
func (client *Client) GetBlockedMessageSenders(req *GetBlockedMessageSendersRequest) (*MessageSenders, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getBlockedMessageSenders",
},
Data: map[string]interface{}{
"offset": req.Offset,
"limit": req.Limit,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalMessageSenders(result.Data)
}
type AddContactRequest struct {
// The contact to add or edit; phone number may be empty and needs to be specified only if known, vCard is ignored
Contact *Contact `json:"contact"`
// Pass true to share the current user's phone number with the new contact. A corresponding rule to userPrivacySettingShowPhoneNumber will be added if needed. Use the field userFullInfo.need_phone_number_privacy_exception to check whether the current user needs to be asked to share their phone number
SharePhoneNumber bool `json:"share_phone_number"`
}
// Adds a user to the contact list or edits an existing contact by their user identifier
func (client *Client) AddContact(req *AddContactRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "addContact",
},
Data: map[string]interface{}{
"contact": req.Contact,
"share_phone_number": req.SharePhoneNumber,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type ImportContactsRequest struct {
// The list of contacts to import or edit; contacts' vCard are ignored and are not imported
Contacts []*Contact `json:"contacts"`
}
// Adds new contacts or edits existing contacts by their phone numbers; contacts' user identifiers are ignored
func (client *Client) ImportContacts(req *ImportContactsRequest) (*ImportedContacts, error) {
result, err := client.Send(Request{
meta: meta{
Type: "importContacts",
},
Data: map[string]interface{}{
"contacts": req.Contacts,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalImportedContacts(result.Data)
}
// Returns all user contacts
func (client *Client) GetContacts() (*Users, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getContacts",
},
Data: map[string]interface{}{},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalUsers(result.Data)
}
type SearchContactsRequest struct {
// Query to search for; may be empty to return all contacts
Query string `json:"query"`
// The maximum number of users to be returned
Limit int32 `json:"limit"`
}
// Searches for the specified query in the first names, last names and usernames of the known user contacts
func (client *Client) SearchContacts(req *SearchContactsRequest) (*Users, error) {
result, err := client.Send(Request{
meta: meta{
Type: "searchContacts",
},
Data: map[string]interface{}{
"query": req.Query,
"limit": req.Limit,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalUsers(result.Data)
}
type RemoveContactsRequest struct {
// Identifiers of users to be deleted
UserIds []int64 `json:"user_ids"`
}
// Removes users from the contact list
func (client *Client) RemoveContacts(req *RemoveContactsRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "removeContacts",
},
Data: map[string]interface{}{
"user_ids": req.UserIds,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
// Returns the total number of imported contacts
func (client *Client) GetImportedContactCount() (*Count, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getImportedContactCount",
},
Data: map[string]interface{}{},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalCount(result.Data)
}
type ChangeImportedContactsRequest struct {
// The new list of contacts, contact's vCard are ignored and are not imported
Contacts []*Contact `json:"contacts"`
}
// Changes imported contacts using the list of contacts saved on the device. Imports newly added contacts and, if at least the file database is enabled, deletes recently deleted contacts. Query result depends on the result of the previous query, so only one query is possible at the same time
func (client *Client) ChangeImportedContacts(req *ChangeImportedContactsRequest) (*ImportedContacts, error) {
result, err := client.Send(Request{
meta: meta{
Type: "changeImportedContacts",
},
Data: map[string]interface{}{
"contacts": req.Contacts,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalImportedContacts(result.Data)
}
// Clears all imported contacts, contact list remains unchanged
func (client *Client) ClearImportedContacts() (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "clearImportedContacts",
},
Data: map[string]interface{}{},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type SearchUserByPhoneNumberRequest struct {
// Phone number to search for
PhoneNumber string `json:"phone_number"`
}
// Searches a user by their phone number. Returns a 404 error if the user can't be found
func (client *Client) SearchUserByPhoneNumber(req *SearchUserByPhoneNumberRequest) (*User, error) {
result, err := client.Send(Request{
meta: meta{
Type: "searchUserByPhoneNumber",
},
Data: map[string]interface{}{
"phone_number": req.PhoneNumber,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalUser(result.Data)
}
type SharePhoneNumberRequest struct {
// Identifier of the user with whom to share the phone number. The user must be a mutual contact
UserId int64 `json:"user_id"`
}
// Shares the phone number of the current user with a mutual contact. Supposed to be called when the user clicks on chatActionBarSharePhoneNumber
func (client *Client) SharePhoneNumber(req *SharePhoneNumberRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "sharePhoneNumber",
},
Data: map[string]interface{}{
"user_id": req.UserId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type GetUserProfilePhotosRequest struct {
// User identifier
UserId int64 `json:"user_id"`
// The number of photos to skip; must be non-negative
Offset int32 `json:"offset"`
// The maximum number of photos to be returned; up to 100
Limit int32 `json:"limit"`
}
// Returns the profile photos of a user. The result of this query may be outdated: some photos might have been deleted already
func (client *Client) GetUserProfilePhotos(req *GetUserProfilePhotosRequest) (*ChatPhotos, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getUserProfilePhotos",
},
Data: map[string]interface{}{
"user_id": req.UserId,
"offset": req.Offset,
"limit": req.Limit,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalChatPhotos(result.Data)
}
type GetStickersRequest struct {
// String representation of emoji. If empty, returns all known installed stickers
Emoji string `json:"emoji"`
// The maximum number of stickers to be returned
Limit int32 `json:"limit"`
}
// Returns stickers from the installed sticker sets that correspond to a given emoji. If the emoji is non-empty, favorite and recently used stickers may also be returned
func (client *Client) GetStickers(req *GetStickersRequest) (*Stickers, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getStickers",
},
Data: map[string]interface{}{
"emoji": req.Emoji,
"limit": req.Limit,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalStickers(result.Data)
}
type SearchStickersRequest struct {
// String representation of emoji; must be non-empty
Emoji string `json:"emoji"`
// The maximum number of stickers to be returned
Limit int32 `json:"limit"`
}
// Searches for stickers from public sticker sets that correspond to a given emoji
func (client *Client) SearchStickers(req *SearchStickersRequest) (*Stickers, error) {
result, err := client.Send(Request{
meta: meta{
Type: "searchStickers",
},
Data: map[string]interface{}{
"emoji": req.Emoji,
"limit": req.Limit,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalStickers(result.Data)
}
type GetInstalledStickerSetsRequest struct {
// Pass true to return mask sticker sets; pass false to return ordinary sticker sets
IsMasks bool `json:"is_masks"`
}
// Returns a list of installed sticker sets
func (client *Client) GetInstalledStickerSets(req *GetInstalledStickerSetsRequest) (*StickerSets, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getInstalledStickerSets",
},
Data: map[string]interface{}{
"is_masks": req.IsMasks,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalStickerSets(result.Data)
}
type GetArchivedStickerSetsRequest struct {
// Pass true to return mask stickers sets; pass false to return ordinary sticker sets
IsMasks bool `json:"is_masks"`
// Identifier of the sticker set from which to return the result
OffsetStickerSetId JsonInt64 `json:"offset_sticker_set_id"`
// The maximum number of sticker sets to return; up to 100
Limit int32 `json:"limit"`
}
// Returns a list of archived sticker sets
func (client *Client) GetArchivedStickerSets(req *GetArchivedStickerSetsRequest) (*StickerSets, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getArchivedStickerSets",
},
Data: map[string]interface{}{
"is_masks": req.IsMasks,
"offset_sticker_set_id": req.OffsetStickerSetId,
"limit": req.Limit,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalStickerSets(result.Data)
}
type GetTrendingStickerSetsRequest struct {
// The offset from which to return the sticker sets; must be non-negative
Offset int32 `json:"offset"`
// The maximum number of sticker sets to be returned; up to 100. For optimal performance, the number of returned sticker sets is chosen by TDLib and can be smaller than the specified limit, even if the end of the list has not been reached
Limit int32 `json:"limit"`
}
// Returns a list of trending sticker sets. For optimal performance, the number of returned sticker sets is chosen by TDLib
func (client *Client) GetTrendingStickerSets(req *GetTrendingStickerSetsRequest) (*StickerSets, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getTrendingStickerSets",
},
Data: map[string]interface{}{
"offset": req.Offset,
"limit": req.Limit,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalStickerSets(result.Data)
}
type GetAttachedStickerSetsRequest struct {
// File identifier
FileId int32 `json:"file_id"`
}
// Returns a list of sticker sets attached to a file. Currently, only photos and videos can have attached sticker sets
func (client *Client) GetAttachedStickerSets(req *GetAttachedStickerSetsRequest) (*StickerSets, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getAttachedStickerSets",
},
Data: map[string]interface{}{
"file_id": req.FileId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalStickerSets(result.Data)
}
type GetStickerSetRequest struct {
// Identifier of the sticker set
SetId JsonInt64 `json:"set_id"`
}
// Returns information about a sticker set by its identifier
func (client *Client) GetStickerSet(req *GetStickerSetRequest) (*StickerSet, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getStickerSet",
},
Data: map[string]interface{}{
"set_id": req.SetId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalStickerSet(result.Data)
}
type SearchStickerSetRequest struct {
// Name of the sticker set
Name string `json:"name"`
}
// Searches for a sticker set by its name
func (client *Client) SearchStickerSet(req *SearchStickerSetRequest) (*StickerSet, error) {
result, err := client.Send(Request{
meta: meta{
Type: "searchStickerSet",
},
Data: map[string]interface{}{
"name": req.Name,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalStickerSet(result.Data)
}
type SearchInstalledStickerSetsRequest struct {
// Pass true to return mask sticker sets; pass false to return ordinary sticker sets
IsMasks bool `json:"is_masks"`
// Query to search for
Query string `json:"query"`
// The maximum number of sticker sets to return
Limit int32 `json:"limit"`
}
// Searches for installed sticker sets by looking for specified query in their title and name
func (client *Client) SearchInstalledStickerSets(req *SearchInstalledStickerSetsRequest) (*StickerSets, error) {
result, err := client.Send(Request{
meta: meta{
Type: "searchInstalledStickerSets",
},
Data: map[string]interface{}{
"is_masks": req.IsMasks,
"query": req.Query,
"limit": req.Limit,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalStickerSets(result.Data)
}
type SearchStickerSetsRequest struct {
// Query to search for
Query string `json:"query"`
}
// Searches for ordinary sticker sets by looking for specified query in their title and name. Excludes installed sticker sets from the results
func (client *Client) SearchStickerSets(req *SearchStickerSetsRequest) (*StickerSets, error) {
result, err := client.Send(Request{
meta: meta{
Type: "searchStickerSets",
},
Data: map[string]interface{}{
"query": req.Query,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalStickerSets(result.Data)
}
type ChangeStickerSetRequest struct {
// Identifier of the sticker set
SetId JsonInt64 `json:"set_id"`
// The new value of is_installed
IsInstalled bool `json:"is_installed"`
// The new value of is_archived. A sticker set can't be installed and archived simultaneously
IsArchived bool `json:"is_archived"`
}
// Installs/uninstalls or activates/archives a sticker set
func (client *Client) ChangeStickerSet(req *ChangeStickerSetRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "changeStickerSet",
},
Data: map[string]interface{}{
"set_id": req.SetId,
"is_installed": req.IsInstalled,
"is_archived": req.IsArchived,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type ViewTrendingStickerSetsRequest struct {
// Identifiers of viewed trending sticker sets
StickerSetIds []JsonInt64 `json:"sticker_set_ids"`
}
// Informs the server that some trending sticker sets have been viewed by the user
func (client *Client) ViewTrendingStickerSets(req *ViewTrendingStickerSetsRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "viewTrendingStickerSets",
},
Data: map[string]interface{}{
"sticker_set_ids": req.StickerSetIds,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type ReorderInstalledStickerSetsRequest struct {
// Pass true to change the order of mask sticker sets; pass false to change the order of ordinary sticker sets
IsMasks bool `json:"is_masks"`
// Identifiers of installed sticker sets in the new correct order
StickerSetIds []JsonInt64 `json:"sticker_set_ids"`
}
// Changes the order of installed sticker sets
func (client *Client) ReorderInstalledStickerSets(req *ReorderInstalledStickerSetsRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "reorderInstalledStickerSets",
},
Data: map[string]interface{}{
"is_masks": req.IsMasks,
"sticker_set_ids": req.StickerSetIds,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type GetRecentStickersRequest struct {
// Pass true to return stickers and masks that were recently attached to photos or video files; pass false to return recently sent stickers
IsAttached bool `json:"is_attached"`
}
// Returns a list of recently used stickers
func (client *Client) GetRecentStickers(req *GetRecentStickersRequest) (*Stickers, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getRecentStickers",
},
Data: map[string]interface{}{
"is_attached": req.IsAttached,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalStickers(result.Data)
}
type AddRecentStickerRequest struct {
// Pass true to add the sticker to the list of stickers recently attached to photo or video files; pass false to add the sticker to the list of recently sent stickers
IsAttached bool `json:"is_attached"`
// Sticker file to add
Sticker InputFile `json:"sticker"`
}
// Manually adds a new sticker to the list of recently used stickers. The new sticker is added to the top of the list. If the sticker was already in the list, it is removed from the list first. Only stickers belonging to a sticker set can be added to this list
func (client *Client) AddRecentSticker(req *AddRecentStickerRequest) (*Stickers, error) {
result, err := client.Send(Request{
meta: meta{
Type: "addRecentSticker",
},
Data: map[string]interface{}{
"is_attached": req.IsAttached,
"sticker": req.Sticker,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalStickers(result.Data)
}
type RemoveRecentStickerRequest struct {
// Pass true to remove the sticker from the list of stickers recently attached to photo or video files; pass false to remove the sticker from the list of recently sent stickers
IsAttached bool `json:"is_attached"`
// Sticker file to delete
Sticker InputFile `json:"sticker"`
}
// Removes a sticker from the list of recently used stickers
func (client *Client) RemoveRecentSticker(req *RemoveRecentStickerRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "removeRecentSticker",
},
Data: map[string]interface{}{
"is_attached": req.IsAttached,
"sticker": req.Sticker,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type ClearRecentStickersRequest struct {
// Pass true to clear the list of stickers recently attached to photo or video files; pass false to clear the list of recently sent stickers
IsAttached bool `json:"is_attached"`
}
// Clears the list of recently used stickers
func (client *Client) ClearRecentStickers(req *ClearRecentStickersRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "clearRecentStickers",
},
Data: map[string]interface{}{
"is_attached": req.IsAttached,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
// Returns favorite stickers
func (client *Client) GetFavoriteStickers() (*Stickers, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getFavoriteStickers",
},
Data: map[string]interface{}{},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalStickers(result.Data)
}
type AddFavoriteStickerRequest struct {
// Sticker file to add
Sticker InputFile `json:"sticker"`
}
// Adds a new sticker to the list of favorite stickers. The new sticker is added to the top of the list. If the sticker was already in the list, it is removed from the list first. Only stickers belonging to a sticker set can be added to this list
func (client *Client) AddFavoriteSticker(req *AddFavoriteStickerRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "addFavoriteSticker",
},
Data: map[string]interface{}{
"sticker": req.Sticker,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type RemoveFavoriteStickerRequest struct {
// Sticker file to delete from the list
Sticker InputFile `json:"sticker"`
}
// Removes a sticker from the list of favorite stickers
func (client *Client) RemoveFavoriteSticker(req *RemoveFavoriteStickerRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "removeFavoriteSticker",
},
Data: map[string]interface{}{
"sticker": req.Sticker,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type GetStickerEmojisRequest struct {
// Sticker file identifier
Sticker InputFile `json:"sticker"`
}
// Returns emoji corresponding to a sticker. The list is only for informational purposes, because a sticker is always sent with a fixed emoji from the corresponding Sticker object
func (client *Client) GetStickerEmojis(req *GetStickerEmojisRequest) (*Emojis, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getStickerEmojis",
},
Data: map[string]interface{}{
"sticker": req.Sticker,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalEmojis(result.Data)
}
type SearchEmojisRequest struct {
// Text to search for
Text string `json:"text"`
// Pass true if only emojis, which exactly match the text, needs to be returned
ExactMatch bool `json:"exact_match"`
// List of possible IETF language tags of the user's input language; may be empty if unknown
InputLanguageCodes []string `json:"input_language_codes"`
}
// Searches for emojis by keywords. Supported only if the file database is enabled
func (client *Client) SearchEmojis(req *SearchEmojisRequest) (*Emojis, error) {
result, err := client.Send(Request{
meta: meta{
Type: "searchEmojis",
},
Data: map[string]interface{}{
"text": req.Text,
"exact_match": req.ExactMatch,
"input_language_codes": req.InputLanguageCodes,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalEmojis(result.Data)
}
type GetAnimatedEmojiRequest struct {
// The emoji
Emoji string `json:"emoji"`
}
// Returns an animated emoji corresponding to a given emoji. Returns a 404 error if the emoji has no animated emoji
func (client *Client) GetAnimatedEmoji(req *GetAnimatedEmojiRequest) (*AnimatedEmoji, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getAnimatedEmoji",
},
Data: map[string]interface{}{
"emoji": req.Emoji,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalAnimatedEmoji(result.Data)
}
type GetEmojiSuggestionsUrlRequest struct {
// Language code for which the emoji replacements will be suggested
LanguageCode string `json:"language_code"`
}
// Returns an HTTP URL which can be used to automatically log in to the translation platform and suggest new emoji replacements. The URL will be valid for 30 seconds after generation
func (client *Client) GetEmojiSuggestionsUrl(req *GetEmojiSuggestionsUrlRequest) (*HttpUrl, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getEmojiSuggestionsUrl",
},
Data: map[string]interface{}{
"language_code": req.LanguageCode,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalHttpUrl(result.Data)
}
// Returns saved animations
func (client *Client) GetSavedAnimations() (*Animations, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getSavedAnimations",
},
Data: map[string]interface{}{},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalAnimations(result.Data)
}
type AddSavedAnimationRequest struct {
// The animation file to be added. Only animations known to the server (i.e., successfully sent via a message) can be added to the list
Animation InputFile `json:"animation"`
}
// Manually adds a new animation to the list of saved animations. The new animation is added to the beginning of the list. If the animation was already in the list, it is removed first. Only non-secret video animations with MIME type "video/mp4" can be added to the list
func (client *Client) AddSavedAnimation(req *AddSavedAnimationRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "addSavedAnimation",
},
Data: map[string]interface{}{
"animation": req.Animation,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type RemoveSavedAnimationRequest struct {
// Animation file to be removed
Animation InputFile `json:"animation"`
}
// Removes an animation from the list of saved animations
func (client *Client) RemoveSavedAnimation(req *RemoveSavedAnimationRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "removeSavedAnimation",
},
Data: map[string]interface{}{
"animation": req.Animation,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
// Returns up to 20 recently used inline bots in the order of their last usage
func (client *Client) GetRecentInlineBots() (*Users, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getRecentInlineBots",
},
Data: map[string]interface{}{},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalUsers(result.Data)
}
type SearchHashtagsRequest struct {
// Hashtag prefix to search for
Prefix string `json:"prefix"`
// The maximum number of hashtags to be returned
Limit int32 `json:"limit"`
}
// Searches for recently used hashtags by their prefix
func (client *Client) SearchHashtags(req *SearchHashtagsRequest) (*Hashtags, error) {
result, err := client.Send(Request{
meta: meta{
Type: "searchHashtags",
},
Data: map[string]interface{}{
"prefix": req.Prefix,
"limit": req.Limit,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalHashtags(result.Data)
}
type RemoveRecentHashtagRequest struct {
// Hashtag to delete
Hashtag string `json:"hashtag"`
}
// Removes a hashtag from the list of recently used hashtags
func (client *Client) RemoveRecentHashtag(req *RemoveRecentHashtagRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "removeRecentHashtag",
},
Data: map[string]interface{}{
"hashtag": req.Hashtag,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type GetWebPagePreviewRequest struct {
// Message text with formatting
Text *FormattedText `json:"text"`
}
// Returns a web page preview by the text of the message. Do not call this function too often. Returns a 404 error if the web page has no preview
func (client *Client) GetWebPagePreview(req *GetWebPagePreviewRequest) (*WebPage, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getWebPagePreview",
},
Data: map[string]interface{}{
"text": req.Text,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalWebPage(result.Data)
}
type GetWebPageInstantViewRequest struct {
// The web page URL
Url string `json:"url"`
// Pass true to get full instant view for the web page
ForceFull bool `json:"force_full"`
}
// Returns an instant view version of a web page if available. Returns a 404 error if the web page has no instant view page
func (client *Client) GetWebPageInstantView(req *GetWebPageInstantViewRequest) (*WebPageInstantView, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getWebPageInstantView",
},
Data: map[string]interface{}{
"url": req.Url,
"force_full": req.ForceFull,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalWebPageInstantView(result.Data)
}
type SetProfilePhotoRequest struct {
// Profile photo to set
Photo InputChatPhoto `json:"photo"`
}
// Changes a profile photo for the current user
func (client *Client) SetProfilePhoto(req *SetProfilePhotoRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "setProfilePhoto",
},
Data: map[string]interface{}{
"photo": req.Photo,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type DeleteProfilePhotoRequest struct {
// Identifier of the profile photo to delete
ProfilePhotoId JsonInt64 `json:"profile_photo_id"`
}
// Deletes a profile photo
func (client *Client) DeleteProfilePhoto(req *DeleteProfilePhotoRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "deleteProfilePhoto",
},
Data: map[string]interface{}{
"profile_photo_id": req.ProfilePhotoId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type SetNameRequest struct {
// The new value of the first name for the current user; 1-64 characters
FirstName string `json:"first_name"`
// The new value of the optional last name for the current user; 0-64 characters
LastName string `json:"last_name"`
}
// Changes the first and last name of the current user
func (client *Client) SetName(req *SetNameRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "setName",
},
Data: map[string]interface{}{
"first_name": req.FirstName,
"last_name": req.LastName,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type SetBioRequest struct {
// The new value of the user bio; 0-70 characters without line feeds
Bio string `json:"bio"`
}
// Changes the bio of the current user
func (client *Client) SetBio(req *SetBioRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "setBio",
},
Data: map[string]interface{}{
"bio": req.Bio,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type SetUsernameRequest struct {
// The new value of the username. Use an empty string to remove the username
Username string `json:"username"`
}
// Changes the username of the current user
func (client *Client) SetUsername(req *SetUsernameRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "setUsername",
},
Data: map[string]interface{}{
"username": req.Username,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type SetLocationRequest struct {
// The new location of the user
Location *Location `json:"location"`
}
// Changes the location of the current user. Needs to be called if GetOption("is_location_visible") is true and location changes for more than 1 kilometer
func (client *Client) SetLocation(req *SetLocationRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "setLocation",
},
Data: map[string]interface{}{
"location": req.Location,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type ChangePhoneNumberRequest struct {
// The new phone number of the user in international format
PhoneNumber string `json:"phone_number"`
// Settings for the authentication of the user's phone number; pass null to use default settings
Settings *PhoneNumberAuthenticationSettings `json:"settings"`
}
// Changes the phone number of the user and sends an authentication code to the user's new phone number. On success, returns information about the sent code
func (client *Client) ChangePhoneNumber(req *ChangePhoneNumberRequest) (*AuthenticationCodeInfo, error) {
result, err := client.Send(Request{
meta: meta{
Type: "changePhoneNumber",
},
Data: map[string]interface{}{
"phone_number": req.PhoneNumber,
"settings": req.Settings,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalAuthenticationCodeInfo(result.Data)
}
// Re-sends the authentication code sent to confirm a new phone number for the current user. Works only if the previously received authenticationCodeInfo next_code_type was not null and the server-specified timeout has passed
func (client *Client) ResendChangePhoneNumberCode() (*AuthenticationCodeInfo, error) {
result, err := client.Send(Request{
meta: meta{
Type: "resendChangePhoneNumberCode",
},
Data: map[string]interface{}{},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalAuthenticationCodeInfo(result.Data)
}
type CheckChangePhoneNumberCodeRequest struct {
// Authentication code to check
Code string `json:"code"`
}
// Checks the authentication code sent to confirm a new phone number of the user
func (client *Client) CheckChangePhoneNumberCode(req *CheckChangePhoneNumberCodeRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "checkChangePhoneNumberCode",
},
Data: map[string]interface{}{
"code": req.Code,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type SetCommandsRequest struct {
// The scope to which the commands are relevant; pass null to change commands in the default bot command scope
Scope BotCommandScope `json:"scope"`
// A two-letter ISO 639-1 language code. If empty, the commands will be applied to all users from the given scope, for which language there are no dedicated commands
LanguageCode string `json:"language_code"`
// List of the bot's commands
Commands []*BotCommand `json:"commands"`
}
// Sets the list of commands supported by the bot for the given user scope and language; for bots only
func (client *Client) SetCommands(req *SetCommandsRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "setCommands",
},
Data: map[string]interface{}{
"scope": req.Scope,
"language_code": req.LanguageCode,
"commands": req.Commands,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type DeleteCommandsRequest struct {
// The scope to which the commands are relevant; pass null to delete commands in the default bot command scope
Scope BotCommandScope `json:"scope"`
// A two-letter ISO 639-1 language code or an empty string
LanguageCode string `json:"language_code"`
}
// Deletes commands supported by the bot for the given user scope and language; for bots only
func (client *Client) DeleteCommands(req *DeleteCommandsRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "deleteCommands",
},
Data: map[string]interface{}{
"scope": req.Scope,
"language_code": req.LanguageCode,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type GetCommandsRequest struct {
// The scope to which the commands are relevant; pass null to get commands in the default bot command scope
Scope BotCommandScope `json:"scope"`
// A two-letter ISO 639-1 language code or an empty string
LanguageCode string `json:"language_code"`
}
// Returns the list of commands supported by the bot for the given user scope and language; for bots only
func (client *Client) GetCommands(req *GetCommandsRequest) (*BotCommands, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getCommands",
},
Data: map[string]interface{}{
"scope": req.Scope,
"language_code": req.LanguageCode,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalBotCommands(result.Data)
}
type SetMenuButtonRequest struct {
// Identifier of the user or 0 to set menu button for all users
UserId int64 `json:"user_id"`
// New menu button
MenuButton *BotMenuButton `json:"menu_button"`
}
// Sets menu button for the given user or for all users; for bots only
func (client *Client) SetMenuButton(req *SetMenuButtonRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "setMenuButton",
},
Data: map[string]interface{}{
"user_id": req.UserId,
"menu_button": req.MenuButton,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type GetMenuButtonRequest struct {
// Identifier of the user or 0 to get the default menu button
UserId int64 `json:"user_id"`
}
// Returns menu button set by the bot for the given user; for bots only
func (client *Client) GetMenuButton(req *GetMenuButtonRequest) (*BotMenuButton, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getMenuButton",
},
Data: map[string]interface{}{
"user_id": req.UserId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalBotMenuButton(result.Data)
}
type SetDefaultGroupAdministratorRightsRequest struct {
// Default administrator rights for adding the bot to basic group and supergroup chats; may be null
DefaultGroupAdministratorRights *ChatAdministratorRights `json:"default_group_administrator_rights"`
}
// Sets default administrator rights for adding the bot to basic group and supergroup chats; for bots only
func (client *Client) SetDefaultGroupAdministratorRights(req *SetDefaultGroupAdministratorRightsRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "setDefaultGroupAdministratorRights",
},
Data: map[string]interface{}{
"default_group_administrator_rights": req.DefaultGroupAdministratorRights,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type SetDefaultChannelAdministratorRightsRequest struct {
// Default administrator rights for adding the bot to channels; may be null
DefaultChannelAdministratorRights *ChatAdministratorRights `json:"default_channel_administrator_rights"`
}
// Sets default administrator rights for adding the bot to channel chats; for bots only
func (client *Client) SetDefaultChannelAdministratorRights(req *SetDefaultChannelAdministratorRightsRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "setDefaultChannelAdministratorRights",
},
Data: map[string]interface{}{
"default_channel_administrator_rights": req.DefaultChannelAdministratorRights,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
// Returns all active sessions of the current user
func (client *Client) GetActiveSessions() (*Sessions, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getActiveSessions",
},
Data: map[string]interface{}{},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalSessions(result.Data)
}
type TerminateSessionRequest struct {
// Session identifier
SessionId JsonInt64 `json:"session_id"`
}
// Terminates a session of the current user
func (client *Client) TerminateSession(req *TerminateSessionRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "terminateSession",
},
Data: map[string]interface{}{
"session_id": req.SessionId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
// Terminates all other sessions of the current user
func (client *Client) TerminateAllOtherSessions() (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "terminateAllOtherSessions",
},
Data: map[string]interface{}{},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type ToggleSessionCanAcceptCallsRequest struct {
// Session identifier
SessionId JsonInt64 `json:"session_id"`
// Pass true to allow accepting incoming calls by the session; pass false otherwise
CanAcceptCalls bool `json:"can_accept_calls"`
}
// Toggles whether a session can accept incoming calls
func (client *Client) ToggleSessionCanAcceptCalls(req *ToggleSessionCanAcceptCallsRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "toggleSessionCanAcceptCalls",
},
Data: map[string]interface{}{
"session_id": req.SessionId,
"can_accept_calls": req.CanAcceptCalls,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type ToggleSessionCanAcceptSecretChatsRequest struct {
// Session identifier
SessionId JsonInt64 `json:"session_id"`
// Pass true to allow accepring secret chats by the session; pass false otherwise
CanAcceptSecretChats bool `json:"can_accept_secret_chats"`
}
// Toggles whether a session can accept incoming secret chats
func (client *Client) ToggleSessionCanAcceptSecretChats(req *ToggleSessionCanAcceptSecretChatsRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "toggleSessionCanAcceptSecretChats",
},
Data: map[string]interface{}{
"session_id": req.SessionId,
"can_accept_secret_chats": req.CanAcceptSecretChats,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type SetInactiveSessionTtlRequest struct {
// New number of days of inactivity before sessions will be automatically terminated; 1-366 days
InactiveSessionTtlDays int32 `json:"inactive_session_ttl_days"`
}
// Changes the period of inactivity after which sessions will automatically be terminated
func (client *Client) SetInactiveSessionTtl(req *SetInactiveSessionTtlRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "setInactiveSessionTtl",
},
Data: map[string]interface{}{
"inactive_session_ttl_days": req.InactiveSessionTtlDays,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
// Returns all website where the current user used Telegram to log in
func (client *Client) GetConnectedWebsites() (*ConnectedWebsites, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getConnectedWebsites",
},
Data: map[string]interface{}{},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalConnectedWebsites(result.Data)
}
type DisconnectWebsiteRequest struct {
// Website identifier
WebsiteId JsonInt64 `json:"website_id"`
}
// Disconnects website from the current user's Telegram account
func (client *Client) DisconnectWebsite(req *DisconnectWebsiteRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "disconnectWebsite",
},
Data: map[string]interface{}{
"website_id": req.WebsiteId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
// Disconnects all websites from the current user's Telegram account
func (client *Client) DisconnectAllWebsites() (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "disconnectAllWebsites",
},
Data: map[string]interface{}{},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type SetSupergroupUsernameRequest struct {
// Identifier of the supergroup or channel
SupergroupId int64 `json:"supergroup_id"`
// New value of the username. Use an empty string to remove the username
Username string `json:"username"`
}
// Changes the username of a supergroup or channel, requires owner privileges in the supergroup or channel
func (client *Client) SetSupergroupUsername(req *SetSupergroupUsernameRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "setSupergroupUsername",
},
Data: map[string]interface{}{
"supergroup_id": req.SupergroupId,
"username": req.Username,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type SetSupergroupStickerSetRequest struct {
// Identifier of the supergroup
SupergroupId int64 `json:"supergroup_id"`
// New value of the supergroup sticker set identifier. Use 0 to remove the supergroup sticker set
StickerSetId JsonInt64 `json:"sticker_set_id"`
}
// Changes the sticker set of a supergroup; requires can_change_info administrator right
func (client *Client) SetSupergroupStickerSet(req *SetSupergroupStickerSetRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "setSupergroupStickerSet",
},
Data: map[string]interface{}{
"supergroup_id": req.SupergroupId,
"sticker_set_id": req.StickerSetId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type ToggleSupergroupSignMessagesRequest struct {
// Identifier of the channel
SupergroupId int64 `json:"supergroup_id"`
// New value of sign_messages
SignMessages bool `json:"sign_messages"`
}
// Toggles whether sender signature is added to sent messages in a channel; requires can_change_info administrator right
func (client *Client) ToggleSupergroupSignMessages(req *ToggleSupergroupSignMessagesRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "toggleSupergroupSignMessages",
},
Data: map[string]interface{}{
"supergroup_id": req.SupergroupId,
"sign_messages": req.SignMessages,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type ToggleSupergroupIsAllHistoryAvailableRequest struct {
// The identifier of the supergroup
SupergroupId int64 `json:"supergroup_id"`
// The new value of is_all_history_available
IsAllHistoryAvailable bool `json:"is_all_history_available"`
}
// Toggles whether the message history of a supergroup is available to new members; requires can_change_info administrator right
func (client *Client) ToggleSupergroupIsAllHistoryAvailable(req *ToggleSupergroupIsAllHistoryAvailableRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "toggleSupergroupIsAllHistoryAvailable",
},
Data: map[string]interface{}{
"supergroup_id": req.SupergroupId,
"is_all_history_available": req.IsAllHistoryAvailable,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type ToggleSupergroupIsBroadcastGroupRequest struct {
// Identifier of the supergroup
SupergroupId int64 `json:"supergroup_id"`
}
// Upgrades supergroup to a broadcast group; requires owner privileges in the supergroup
func (client *Client) ToggleSupergroupIsBroadcastGroup(req *ToggleSupergroupIsBroadcastGroupRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "toggleSupergroupIsBroadcastGroup",
},
Data: map[string]interface{}{
"supergroup_id": req.SupergroupId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type ReportSupergroupSpamRequest struct {
// Supergroup identifier
SupergroupId int64 `json:"supergroup_id"`
// Identifiers of messages to report
MessageIds []int64 `json:"message_ids"`
}
// Reports messages in a supergroup as spam; requires administrator rights in the supergroup
func (client *Client) ReportSupergroupSpam(req *ReportSupergroupSpamRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "reportSupergroupSpam",
},
Data: map[string]interface{}{
"supergroup_id": req.SupergroupId,
"message_ids": req.MessageIds,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type GetSupergroupMembersRequest struct {
// Identifier of the supergroup or channel
SupergroupId int64 `json:"supergroup_id"`
// The type of users to return; pass null to use supergroupMembersFilterRecent
Filter SupergroupMembersFilter `json:"filter"`
// Number of users to skip
Offset int32 `json:"offset"`
// The maximum number of users be returned; up to 200
Limit int32 `json:"limit"`
}
// Returns information about members or banned users in a supergroup or channel. Can be used only if supergroupFullInfo.can_get_members == true; additionally, administrator privileges may be required for some filters
func (client *Client) GetSupergroupMembers(req *GetSupergroupMembersRequest) (*ChatMembers, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getSupergroupMembers",
},
Data: map[string]interface{}{
"supergroup_id": req.SupergroupId,
"filter": req.Filter,
"offset": req.Offset,
"limit": req.Limit,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalChatMembers(result.Data)
}
type CloseSecretChatRequest struct {
// Secret chat identifier
SecretChatId int32 `json:"secret_chat_id"`
}
// Closes a secret chat, effectively transferring its state to secretChatStateClosed
func (client *Client) CloseSecretChat(req *CloseSecretChatRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "closeSecretChat",
},
Data: map[string]interface{}{
"secret_chat_id": req.SecretChatId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type GetChatEventLogRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
// Search query by which to filter events
Query string `json:"query"`
// Identifier of an event from which to return results. Use 0 to get results from the latest events
FromEventId JsonInt64 `json:"from_event_id"`
// The maximum number of events to return; up to 100
Limit int32 `json:"limit"`
// The types of events to return; pass null to get chat events of all types
Filters *ChatEventLogFilters `json:"filters"`
// User identifiers by which to filter events. By default, events relating to all users will be returned
UserIds []int64 `json:"user_ids"`
}
// Returns a list of service actions taken by chat members and administrators in the last 48 hours. Available only for supergroups and channels. Requires administrator rights. Returns results in reverse chronological order (i. e., in order of decreasing event_id)
func (client *Client) GetChatEventLog(req *GetChatEventLogRequest) (*ChatEvents, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getChatEventLog",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"query": req.Query,
"from_event_id": req.FromEventId,
"limit": req.Limit,
"filters": req.Filters,
"user_ids": req.UserIds,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalChatEvents(result.Data)
}
type GetPaymentFormRequest struct {
// Chat identifier of the Invoice message
ChatId int64 `json:"chat_id"`
// Message identifier
MessageId int64 `json:"message_id"`
// Preferred payment form theme; pass null to use the default theme
Theme *ThemeParameters `json:"theme"`
}
// Returns an invoice payment form. This method must be called when the user presses inlineKeyboardButtonBuy
func (client *Client) GetPaymentForm(req *GetPaymentFormRequest) (*PaymentForm, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getPaymentForm",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"message_id": req.MessageId,
"theme": req.Theme,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalPaymentForm(result.Data)
}
type ValidateOrderInfoRequest struct {
// Chat identifier of the Invoice message
ChatId int64 `json:"chat_id"`
// Message identifier
MessageId int64 `json:"message_id"`
// The order information, provided by the user; pass null if empty
OrderInfo *OrderInfo `json:"order_info"`
// Pass true to save the order information
AllowSave bool `json:"allow_save"`
}
// Validates the order information provided by a user and returns the available shipping options for a flexible invoice
func (client *Client) ValidateOrderInfo(req *ValidateOrderInfoRequest) (*ValidatedOrderInfo, error) {
result, err := client.Send(Request{
meta: meta{
Type: "validateOrderInfo",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"message_id": req.MessageId,
"order_info": req.OrderInfo,
"allow_save": req.AllowSave,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalValidatedOrderInfo(result.Data)
}
type SendPaymentFormRequest struct {
// Chat identifier of the Invoice message
ChatId int64 `json:"chat_id"`
// Message identifier
MessageId int64 `json:"message_id"`
// Payment form identifier returned by getPaymentForm
PaymentFormId JsonInt64 `json:"payment_form_id"`
// Identifier returned by validateOrderInfo, or an empty string
OrderInfoId string `json:"order_info_id"`
// Identifier of a chosen shipping option, if applicable
ShippingOptionId string `json:"shipping_option_id"`
// The credentials chosen by user for payment
Credentials InputCredentials `json:"credentials"`
// Chosen by the user amount of tip in the smallest units of the currency
TipAmount int64 `json:"tip_amount"`
}
// Sends a filled-out payment form to the bot for final verification
func (client *Client) SendPaymentForm(req *SendPaymentFormRequest) (*PaymentResult, error) {
result, err := client.Send(Request{
meta: meta{
Type: "sendPaymentForm",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"message_id": req.MessageId,
"payment_form_id": req.PaymentFormId,
"order_info_id": req.OrderInfoId,
"shipping_option_id": req.ShippingOptionId,
"credentials": req.Credentials,
"tip_amount": req.TipAmount,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalPaymentResult(result.Data)
}
type GetPaymentReceiptRequest struct {
// Chat identifier of the PaymentSuccessful message
ChatId int64 `json:"chat_id"`
// Message identifier
MessageId int64 `json:"message_id"`
}
// Returns information about a successful payment
func (client *Client) GetPaymentReceipt(req *GetPaymentReceiptRequest) (*PaymentReceipt, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getPaymentReceipt",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"message_id": req.MessageId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalPaymentReceipt(result.Data)
}
// Returns saved order information. Returns a 404 error if there is no saved order information
func (client *Client) GetSavedOrderInfo() (*OrderInfo, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getSavedOrderInfo",
},
Data: map[string]interface{}{},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOrderInfo(result.Data)
}
// Deletes saved order information
func (client *Client) DeleteSavedOrderInfo() (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "deleteSavedOrderInfo",
},
Data: map[string]interface{}{},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
// Deletes saved credentials for all payment provider bots
func (client *Client) DeleteSavedCredentials() (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "deleteSavedCredentials",
},
Data: map[string]interface{}{},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
// Returns a user that can be contacted to get support
func (client *Client) GetSupportUser() (*User, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getSupportUser",
},
Data: map[string]interface{}{},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalUser(result.Data)
}
type GetBackgroundsRequest struct {
// Pass true to order returned backgrounds for a dark theme
ForDarkTheme bool `json:"for_dark_theme"`
}
// Returns backgrounds installed by the user
func (client *Client) GetBackgrounds(req *GetBackgroundsRequest) (*Backgrounds, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getBackgrounds",
},
Data: map[string]interface{}{
"for_dark_theme": req.ForDarkTheme,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalBackgrounds(result.Data)
}
type GetBackgroundUrlRequest struct {
// Background name
Name string `json:"name"`
// Background type
Type BackgroundType `json:"type"`
}
// Constructs a persistent HTTP URL for a background
func (client *Client) GetBackgroundUrl(req *GetBackgroundUrlRequest) (*HttpUrl, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getBackgroundUrl",
},
Data: map[string]interface{}{
"name": req.Name,
"type": req.Type,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalHttpUrl(result.Data)
}
type SearchBackgroundRequest struct {
// The name of the background
Name string `json:"name"`
}
// Searches for a background by its name
func (client *Client) SearchBackground(req *SearchBackgroundRequest) (*Background, error) {
result, err := client.Send(Request{
meta: meta{
Type: "searchBackground",
},
Data: map[string]interface{}{
"name": req.Name,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalBackground(result.Data)
}
type SetBackgroundRequest struct {
// The input background to use; pass null to create a new filled backgrounds or to remove the current background
Background InputBackground `json:"background"`
// Background type; pass null to use the default type of the remote background or to remove the current background
Type BackgroundType `json:"type"`
// Pass true if the background is changed for a dark theme
ForDarkTheme bool `json:"for_dark_theme"`
}
// Changes the background selected by the user; adds background to the list of installed backgrounds
func (client *Client) SetBackground(req *SetBackgroundRequest) (*Background, error) {
result, err := client.Send(Request{
meta: meta{
Type: "setBackground",
},
Data: map[string]interface{}{
"background": req.Background,
"type": req.Type,
"for_dark_theme": req.ForDarkTheme,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalBackground(result.Data)
}
type RemoveBackgroundRequest struct {
// The background identifier
BackgroundId JsonInt64 `json:"background_id"`
}
// Removes background from the list of installed backgrounds
func (client *Client) RemoveBackground(req *RemoveBackgroundRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "removeBackground",
},
Data: map[string]interface{}{
"background_id": req.BackgroundId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
// Resets list of installed backgrounds to its default value
func (client *Client) ResetBackgrounds() (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "resetBackgrounds",
},
Data: map[string]interface{}{},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type GetLocalizationTargetInfoRequest struct {
// Pass true to get only locally available information without sending network requests
OnlyLocal bool `json:"only_local"`
}
// Returns information about the current localization target. This is an offline request if only_local is true. Can be called before authorization
func (client *Client) GetLocalizationTargetInfo(req *GetLocalizationTargetInfoRequest) (*LocalizationTargetInfo, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getLocalizationTargetInfo",
},
Data: map[string]interface{}{
"only_local": req.OnlyLocal,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalLocalizationTargetInfo(result.Data)
}
type GetLanguagePackInfoRequest struct {
// Language pack identifier
LanguagePackId string `json:"language_pack_id"`
}
// Returns information about a language pack. Returned language pack identifier may be different from a provided one. Can be called before authorization
func (client *Client) GetLanguagePackInfo(req *GetLanguagePackInfoRequest) (*LanguagePackInfo, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getLanguagePackInfo",
},
Data: map[string]interface{}{
"language_pack_id": req.LanguagePackId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalLanguagePackInfo(result.Data)
}
type GetLanguagePackStringsRequest struct {
// Language pack identifier of the strings to be returned
LanguagePackId string `json:"language_pack_id"`
// Language pack keys of the strings to be returned; leave empty to request all available strings
Keys []string `json:"keys"`
}
// Returns strings from a language pack in the current localization target by their keys. Can be called before authorization
func (client *Client) GetLanguagePackStrings(req *GetLanguagePackStringsRequest) (*LanguagePackStrings, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getLanguagePackStrings",
},
Data: map[string]interface{}{
"language_pack_id": req.LanguagePackId,
"keys": req.Keys,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalLanguagePackStrings(result.Data)
}
type SynchronizeLanguagePackRequest struct {
// Language pack identifier
LanguagePackId string `json:"language_pack_id"`
}
// Fetches the latest versions of all strings from a language pack in the current localization target from the server. This method doesn't need to be called explicitly for the current used/base language packs. Can be called before authorization
func (client *Client) SynchronizeLanguagePack(req *SynchronizeLanguagePackRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "synchronizeLanguagePack",
},
Data: map[string]interface{}{
"language_pack_id": req.LanguagePackId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type AddCustomServerLanguagePackRequest struct {
// Identifier of a language pack to be added; may be different from a name that is used in an "https://t.me/setlanguage/" link
LanguagePackId string `json:"language_pack_id"`
}
// Adds a custom server language pack to the list of installed language packs in current localization target. Can be called before authorization
func (client *Client) AddCustomServerLanguagePack(req *AddCustomServerLanguagePackRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "addCustomServerLanguagePack",
},
Data: map[string]interface{}{
"language_pack_id": req.LanguagePackId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type SetCustomLanguagePackRequest struct {
// Information about the language pack. Language pack ID must start with 'X', consist only of English letters, digits and hyphens, and must not exceed 64 characters. Can be called before authorization
Info *LanguagePackInfo `json:"info"`
// Strings of the new language pack
Strings []*LanguagePackString `json:"strings"`
}
// Adds or changes a custom local language pack to the current localization target
func (client *Client) SetCustomLanguagePack(req *SetCustomLanguagePackRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "setCustomLanguagePack",
},
Data: map[string]interface{}{
"info": req.Info,
"strings": req.Strings,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type EditCustomLanguagePackInfoRequest struct {
// New information about the custom local language pack
Info *LanguagePackInfo `json:"info"`
}
// Edits information about a custom local language pack in the current localization target. Can be called before authorization
func (client *Client) EditCustomLanguagePackInfo(req *EditCustomLanguagePackInfoRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "editCustomLanguagePackInfo",
},
Data: map[string]interface{}{
"info": req.Info,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type SetCustomLanguagePackStringRequest struct {
// Identifier of a previously added custom local language pack in the current localization target
LanguagePackId string `json:"language_pack_id"`
// New language pack string
NewString *LanguagePackString `json:"new_string"`
}
// Adds, edits or deletes a string in a custom local language pack. Can be called before authorization
func (client *Client) SetCustomLanguagePackString(req *SetCustomLanguagePackStringRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "setCustomLanguagePackString",
},
Data: map[string]interface{}{
"language_pack_id": req.LanguagePackId,
"new_string": req.NewString,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type DeleteLanguagePackRequest struct {
// Identifier of the language pack to delete
LanguagePackId string `json:"language_pack_id"`
}
// Deletes all information about a language pack in the current localization target. The language pack which is currently in use (including base language pack) or is being synchronized can't be deleted. Can be called before authorization
func (client *Client) DeleteLanguagePack(req *DeleteLanguagePackRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "deleteLanguagePack",
},
Data: map[string]interface{}{
"language_pack_id": req.LanguagePackId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type RegisterDeviceRequest struct {
// Device token
DeviceToken DeviceToken `json:"device_token"`
// List of user identifiers of other users currently using the application
OtherUserIds []int64 `json:"other_user_ids"`
}
// Registers the currently used device for receiving push notifications. Returns a globally unique identifier of the push notification subscription
func (client *Client) RegisterDevice(req *RegisterDeviceRequest) (*PushReceiverId, error) {
result, err := client.Send(Request{
meta: meta{
Type: "registerDevice",
},
Data: map[string]interface{}{
"device_token": req.DeviceToken,
"other_user_ids": req.OtherUserIds,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalPushReceiverId(result.Data)
}
type ProcessPushNotificationRequest struct {
// JSON-encoded push notification payload with all fields sent by the server, and "google.sent_time" and "google.notification.sound" fields added
Payload string `json:"payload"`
}
// Handles a push notification. Returns error with code 406 if the push notification is not supported and connection to the server is required to fetch new data. Can be called before authorization
func (client *Client) ProcessPushNotification(req *ProcessPushNotificationRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "processPushNotification",
},
Data: map[string]interface{}{
"payload": req.Payload,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type GetPushReceiverIdRequest struct {
// JSON-encoded push notification payload
Payload string `json:"payload"`
}
// Returns a globally unique push notification subscription identifier for identification of an account, which has received a push notification. Can be called synchronously
func GetPushReceiverId(req *GetPushReceiverIdRequest) (*PushReceiverId, error) {
result, err := Execute(Request{
meta: meta{
Type: "getPushReceiverId",
},
Data: map[string]interface{}{
"payload": req.Payload,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalPushReceiverId(result.Data)
}
// deprecated
// Returns a globally unique push notification subscription identifier for identification of an account, which has received a push notification. Can be called synchronously
func (client *Client) GetPushReceiverId(req *GetPushReceiverIdRequest) (*PushReceiverId, error) {
return GetPushReceiverId(req)}
type GetRecentlyVisitedTMeUrlsRequest struct {
// Google Play referrer to identify the user
Referrer string `json:"referrer"`
}
// Returns t.me URLs recently visited by a newly registered user
func (client *Client) GetRecentlyVisitedTMeUrls(req *GetRecentlyVisitedTMeUrlsRequest) (*TMeUrls, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getRecentlyVisitedTMeUrls",
},
Data: map[string]interface{}{
"referrer": req.Referrer,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalTMeUrls(result.Data)
}
type SetUserPrivacySettingRulesRequest struct {
// The privacy setting
Setting UserPrivacySetting `json:"setting"`
// The new privacy rules
Rules *UserPrivacySettingRules `json:"rules"`
}
// Changes user privacy settings
func (client *Client) SetUserPrivacySettingRules(req *SetUserPrivacySettingRulesRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "setUserPrivacySettingRules",
},
Data: map[string]interface{}{
"setting": req.Setting,
"rules": req.Rules,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type GetUserPrivacySettingRulesRequest struct {
// The privacy setting
Setting UserPrivacySetting `json:"setting"`
}
// Returns the current privacy settings
func (client *Client) GetUserPrivacySettingRules(req *GetUserPrivacySettingRulesRequest) (*UserPrivacySettingRules, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getUserPrivacySettingRules",
},
Data: map[string]interface{}{
"setting": req.Setting,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalUserPrivacySettingRules(result.Data)
}
type GetOptionRequest struct {
// The name of the option
Name string `json:"name"`
}
// Returns the value of an option by its name. (Check the list of available options on https://core.telegram.org/tdlib/options.) Can be called before authorization
func (client *Client) GetOption(req *GetOptionRequest) (OptionValue, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getOption",
},
Data: map[string]interface{}{
"name": req.Name,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
switch result.Type {
case TypeOptionValueBoolean:
return UnmarshalOptionValueBoolean(result.Data)
case TypeOptionValueEmpty:
return UnmarshalOptionValueEmpty(result.Data)
case TypeOptionValueInteger:
return UnmarshalOptionValueInteger(result.Data)
case TypeOptionValueString:
return UnmarshalOptionValueString(result.Data)
default:
return nil, errors.New("invalid type")
}
}
type SetOptionRequest struct {
// The name of the option
Name string `json:"name"`
// The new value of the option; pass null to reset option value to a default value
Value OptionValue `json:"value"`
}
// Sets the value of an option. (Check the list of available options on https://core.telegram.org/tdlib/options.) Only writable options can be set. Can be called before authorization
func (client *Client) SetOption(req *SetOptionRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "setOption",
},
Data: map[string]interface{}{
"name": req.Name,
"value": req.Value,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type SetAccountTtlRequest struct {
// New account TTL
Ttl *AccountTtl `json:"ttl"`
}
// Changes the period of inactivity after which the account of the current user will automatically be deleted
func (client *Client) SetAccountTtl(req *SetAccountTtlRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "setAccountTtl",
},
Data: map[string]interface{}{
"ttl": req.Ttl,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
// Returns the period of inactivity after which the account of the current user will automatically be deleted
func (client *Client) GetAccountTtl() (*AccountTtl, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getAccountTtl",
},
Data: map[string]interface{}{},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalAccountTtl(result.Data)
}
type DeleteAccountRequest struct {
// The reason why the account was deleted; optional
Reason string `json:"reason"`
}
// Deletes the account of the current user, deleting all information associated with the user from the server. The phone number of the account can be used to create a new account. Can be called before authorization when the current authorization state is authorizationStateWaitPassword
func (client *Client) DeleteAccount(req *DeleteAccountRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "deleteAccount",
},
Data: map[string]interface{}{
"reason": req.Reason,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type RemoveChatActionBarRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
}
// Removes a chat action bar without any other action
func (client *Client) RemoveChatActionBar(req *RemoveChatActionBarRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "removeChatActionBar",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type ReportChatRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
// Identifiers of reported messages; may be empty to report the whole chat
MessageIds []int64 `json:"message_ids"`
// The reason for reporting the chat
Reason ChatReportReason `json:"reason"`
// Additional report details; 0-1024 characters
Text string `json:"text"`
}
// Reports a chat to the Telegram moderators. A chat can be reported only from the chat action bar, or if chat.can_be_reported
func (client *Client) ReportChat(req *ReportChatRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "reportChat",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"message_ids": req.MessageIds,
"reason": req.Reason,
"text": req.Text,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type ReportChatPhotoRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
// Identifier of the photo to report. Only full photos from chatPhoto can be reported
FileId int32 `json:"file_id"`
// The reason for reporting the chat photo
Reason ChatReportReason `json:"reason"`
// Additional report details; 0-1024 characters
Text string `json:"text"`
}
// Reports a chat photo to the Telegram moderators. A chat photo can be reported only if chat.can_be_reported
func (client *Client) ReportChatPhoto(req *ReportChatPhotoRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "reportChatPhoto",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"file_id": req.FileId,
"reason": req.Reason,
"text": req.Text,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type GetChatStatisticsRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
// Pass true if a dark theme is used by the application
IsDark bool `json:"is_dark"`
}
// Returns detailed statistics about a chat. Currently, this method can be used only for supergroups and channels. Can be used only if supergroupFullInfo.can_get_statistics == true
func (client *Client) GetChatStatistics(req *GetChatStatisticsRequest) (ChatStatistics, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getChatStatistics",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"is_dark": req.IsDark,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
switch result.Type {
case TypeChatStatisticsSupergroup:
return UnmarshalChatStatisticsSupergroup(result.Data)
case TypeChatStatisticsChannel:
return UnmarshalChatStatisticsChannel(result.Data)
default:
return nil, errors.New("invalid type")
}
}
type GetMessageStatisticsRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
// Message identifier
MessageId int64 `json:"message_id"`
// Pass true if a dark theme is used by the application
IsDark bool `json:"is_dark"`
}
// Returns detailed statistics about a message. Can be used only if message.can_get_statistics == true
func (client *Client) GetMessageStatistics(req *GetMessageStatisticsRequest) (*MessageStatistics, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getMessageStatistics",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"message_id": req.MessageId,
"is_dark": req.IsDark,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalMessageStatistics(result.Data)
}
type GetStatisticalGraphRequest struct {
// Chat identifier
ChatId int64 `json:"chat_id"`
// The token for graph loading
Token string `json:"token"`
// X-value for zoomed in graph or 0 otherwise
X int64 `json:"x"`
}
// Loads an asynchronous or a zoomed in statistical graph
func (client *Client) GetStatisticalGraph(req *GetStatisticalGraphRequest) (StatisticalGraph, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getStatisticalGraph",
},
Data: map[string]interface{}{
"chat_id": req.ChatId,
"token": req.Token,
"x": req.X,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
switch result.Type {
case TypeStatisticalGraphData:
return UnmarshalStatisticalGraphData(result.Data)
case TypeStatisticalGraphAsync:
return UnmarshalStatisticalGraphAsync(result.Data)
case TypeStatisticalGraphError:
return UnmarshalStatisticalGraphError(result.Data)
default:
return nil, errors.New("invalid type")
}
}
type GetStorageStatisticsRequest struct {
// The maximum number of chats with the largest storage usage for which separate statistics need to be returned. All other chats will be grouped in entries with chat_id == 0. If the chat info database is not used, the chat_limit is ignored and is always set to 0
ChatLimit int32 `json:"chat_limit"`
}
// Returns storage usage statistics. Can be called before authorization
func (client *Client) GetStorageStatistics(req *GetStorageStatisticsRequest) (*StorageStatistics, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getStorageStatistics",
},
Data: map[string]interface{}{
"chat_limit": req.ChatLimit,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalStorageStatistics(result.Data)
}
// Quickly returns approximate storage usage statistics. Can be called before authorization
func (client *Client) GetStorageStatisticsFast() (*StorageStatisticsFast, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getStorageStatisticsFast",
},
Data: map[string]interface{}{},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalStorageStatisticsFast(result.Data)
}
// Returns database statistics
func (client *Client) GetDatabaseStatistics() (*DatabaseStatistics, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getDatabaseStatistics",
},
Data: map[string]interface{}{},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalDatabaseStatistics(result.Data)
}
type OptimizeStorageRequest struct {
// Limit on the total size of files after deletion, in bytes. Pass -1 to use the default limit
Size int64 `json:"size"`
// Limit on the time that has passed since the last time a file was accessed (or creation time for some filesystems). Pass -1 to use the default limit
Ttl int32 `json:"ttl"`
// Limit on the total number of files after deletion. Pass -1 to use the default limit
Count int32 `json:"count"`
// The amount of time after the creation of a file during which it can't be deleted, in seconds. Pass -1 to use the default value
ImmunityDelay int32 `json:"immunity_delay"`
// If non-empty, only files with the given types are considered. By default, all types except thumbnails, profile photos, stickers and wallpapers are deleted
FileTypes []FileType `json:"file_types"`
// If non-empty, only files from the given chats are considered. Use 0 as chat identifier to delete files not belonging to any chat (e.g., profile photos)
ChatIds []int64 `json:"chat_ids"`
// If non-empty, files from the given chats are excluded. Use 0 as chat identifier to exclude all files not belonging to any chat (e.g., profile photos)
ExcludeChatIds []int64 `json:"exclude_chat_ids"`
// Pass true if statistics about the files that were deleted must be returned instead of the whole storage usage statistics. Affects only returned statistics
ReturnDeletedFileStatistics bool `json:"return_deleted_file_statistics"`
// Same as in getStorageStatistics. Affects only returned statistics
ChatLimit int32 `json:"chat_limit"`
}
// Optimizes storage usage, i.e. deletes some files and returns new storage usage statistics. Secret thumbnails can't be deleted
func (client *Client) OptimizeStorage(req *OptimizeStorageRequest) (*StorageStatistics, error) {
result, err := client.Send(Request{
meta: meta{
Type: "optimizeStorage",
},
Data: map[string]interface{}{
"size": req.Size,
"ttl": req.Ttl,
"count": req.Count,
"immunity_delay": req.ImmunityDelay,
"file_types": req.FileTypes,
"chat_ids": req.ChatIds,
"exclude_chat_ids": req.ExcludeChatIds,
"return_deleted_file_statistics": req.ReturnDeletedFileStatistics,
"chat_limit": req.ChatLimit,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalStorageStatistics(result.Data)
}
type SetNetworkTypeRequest struct {
// The new network type; pass null to set network type to networkTypeOther
Type NetworkType `json:"type"`
}
// Sets the current network type. Can be called before authorization. Calling this method forces all network connections to reopen, mitigating the delay in switching between different networks, so it must be called whenever the network is changed, even if the network type remains the same. Network type is used to check whether the library can use the network at all and also for collecting detailed network data usage statistics
func (client *Client) SetNetworkType(req *SetNetworkTypeRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "setNetworkType",
},
Data: map[string]interface{}{
"type": req.Type,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type GetNetworkStatisticsRequest struct {
// Pass true to get statistics only for the current library launch
OnlyCurrent bool `json:"only_current"`
}
// Returns network data usage statistics. Can be called before authorization
func (client *Client) GetNetworkStatistics(req *GetNetworkStatisticsRequest) (*NetworkStatistics, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getNetworkStatistics",
},
Data: map[string]interface{}{
"only_current": req.OnlyCurrent,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalNetworkStatistics(result.Data)
}
type AddNetworkStatisticsRequest struct {
// The network statistics entry with the data to be added to statistics
Entry NetworkStatisticsEntry `json:"entry"`
}
// Adds the specified data to data usage statistics. Can be called before authorization
func (client *Client) AddNetworkStatistics(req *AddNetworkStatisticsRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "addNetworkStatistics",
},
Data: map[string]interface{}{
"entry": req.Entry,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
// Resets all network data usage statistics to zero. Can be called before authorization
func (client *Client) ResetNetworkStatistics() (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "resetNetworkStatistics",
},
Data: map[string]interface{}{},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
// Returns auto-download settings presets for the current user
func (client *Client) GetAutoDownloadSettingsPresets() (*AutoDownloadSettingsPresets, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getAutoDownloadSettingsPresets",
},
Data: map[string]interface{}{},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalAutoDownloadSettingsPresets(result.Data)
}
type SetAutoDownloadSettingsRequest struct {
// New user auto-download settings
Settings *AutoDownloadSettings `json:"settings"`
// Type of the network for which the new settings are relevant
Type NetworkType `json:"type"`
}
// Sets auto-download settings
func (client *Client) SetAutoDownloadSettings(req *SetAutoDownloadSettingsRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "setAutoDownloadSettings",
},
Data: map[string]interface{}{
"settings": req.Settings,
"type": req.Type,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type GetBankCardInfoRequest struct {
// The bank card number
BankCardNumber string `json:"bank_card_number"`
}
// Returns information about a bank card
func (client *Client) GetBankCardInfo(req *GetBankCardInfoRequest) (*BankCardInfo, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getBankCardInfo",
},
Data: map[string]interface{}{
"bank_card_number": req.BankCardNumber,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalBankCardInfo(result.Data)
}
type GetPassportElementRequest struct {
// Telegram Passport element type
Type PassportElementType `json:"type"`
// Password of the current user
Password string `json:"password"`
}
// Returns one of the available Telegram Passport elements
func (client *Client) GetPassportElement(req *GetPassportElementRequest) (PassportElement, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getPassportElement",
},
Data: map[string]interface{}{
"type": req.Type,
"password": req.Password,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
switch result.Type {
case TypePassportElementPersonalDetails:
return UnmarshalPassportElementPersonalDetails(result.Data)
case TypePassportElementPassport:
return UnmarshalPassportElementPassport(result.Data)
case TypePassportElementDriverLicense:
return UnmarshalPassportElementDriverLicense(result.Data)
case TypePassportElementIdentityCard:
return UnmarshalPassportElementIdentityCard(result.Data)
case TypePassportElementInternalPassport:
return UnmarshalPassportElementInternalPassport(result.Data)
case TypePassportElementAddress:
return UnmarshalPassportElementAddress(result.Data)
case TypePassportElementUtilityBill:
return UnmarshalPassportElementUtilityBill(result.Data)
case TypePassportElementBankStatement:
return UnmarshalPassportElementBankStatement(result.Data)
case TypePassportElementRentalAgreement:
return UnmarshalPassportElementRentalAgreement(result.Data)
case TypePassportElementPassportRegistration:
return UnmarshalPassportElementPassportRegistration(result.Data)
case TypePassportElementTemporaryRegistration:
return UnmarshalPassportElementTemporaryRegistration(result.Data)
case TypePassportElementPhoneNumber:
return UnmarshalPassportElementPhoneNumber(result.Data)
case TypePassportElementEmailAddress:
return UnmarshalPassportElementEmailAddress(result.Data)
default:
return nil, errors.New("invalid type")
}
}
type GetAllPassportElementsRequest struct {
// Password of the current user
Password string `json:"password"`
}
// Returns all available Telegram Passport elements
func (client *Client) GetAllPassportElements(req *GetAllPassportElementsRequest) (*PassportElements, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getAllPassportElements",
},
Data: map[string]interface{}{
"password": req.Password,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalPassportElements(result.Data)
}
type SetPassportElementRequest struct {
// Input Telegram Passport element
Element InputPassportElement `json:"element"`
// Password of the current user
Password string `json:"password"`
}
// Adds an element to the user's Telegram Passport. May return an error with a message "PHONE_VERIFICATION_NEEDED" or "EMAIL_VERIFICATION_NEEDED" if the chosen phone number or the chosen email address must be verified first
func (client *Client) SetPassportElement(req *SetPassportElementRequest) (PassportElement, error) {
result, err := client.Send(Request{
meta: meta{
Type: "setPassportElement",
},
Data: map[string]interface{}{
"element": req.Element,
"password": req.Password,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
switch result.Type {
case TypePassportElementPersonalDetails:
return UnmarshalPassportElementPersonalDetails(result.Data)
case TypePassportElementPassport:
return UnmarshalPassportElementPassport(result.Data)
case TypePassportElementDriverLicense:
return UnmarshalPassportElementDriverLicense(result.Data)
case TypePassportElementIdentityCard:
return UnmarshalPassportElementIdentityCard(result.Data)
case TypePassportElementInternalPassport:
return UnmarshalPassportElementInternalPassport(result.Data)
case TypePassportElementAddress:
return UnmarshalPassportElementAddress(result.Data)
case TypePassportElementUtilityBill:
return UnmarshalPassportElementUtilityBill(result.Data)
case TypePassportElementBankStatement:
return UnmarshalPassportElementBankStatement(result.Data)
case TypePassportElementRentalAgreement:
return UnmarshalPassportElementRentalAgreement(result.Data)
case TypePassportElementPassportRegistration:
return UnmarshalPassportElementPassportRegistration(result.Data)
case TypePassportElementTemporaryRegistration:
return UnmarshalPassportElementTemporaryRegistration(result.Data)
case TypePassportElementPhoneNumber:
return UnmarshalPassportElementPhoneNumber(result.Data)
case TypePassportElementEmailAddress:
return UnmarshalPassportElementEmailAddress(result.Data)
default:
return nil, errors.New("invalid type")
}
}
type DeletePassportElementRequest struct {
// Element type
Type PassportElementType `json:"type"`
}
// Deletes a Telegram Passport element
func (client *Client) DeletePassportElement(req *DeletePassportElementRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "deletePassportElement",
},
Data: map[string]interface{}{
"type": req.Type,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type SetPassportElementErrorsRequest struct {
// User identifier
UserId int64 `json:"user_id"`
// The errors
Errors []*InputPassportElementError `json:"errors"`
}
// Informs the user that some of the elements in their Telegram Passport contain errors; for bots only. The user will not be able to resend the elements, until the errors are fixed
func (client *Client) SetPassportElementErrors(req *SetPassportElementErrorsRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "setPassportElementErrors",
},
Data: map[string]interface{}{
"user_id": req.UserId,
"errors": req.Errors,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type GetPreferredCountryLanguageRequest struct {
// A two-letter ISO 3166-1 alpha-2 country code
CountryCode string `json:"country_code"`
}
// Returns an IETF language tag of the language preferred in the country, which must be used to fill native fields in Telegram Passport personal details. Returns a 404 error if unknown
func (client *Client) GetPreferredCountryLanguage(req *GetPreferredCountryLanguageRequest) (*Text, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getPreferredCountryLanguage",
},
Data: map[string]interface{}{
"country_code": req.CountryCode,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalText(result.Data)
}
type SendPhoneNumberVerificationCodeRequest struct {
// The phone number of the user, in international format
PhoneNumber string `json:"phone_number"`
// Settings for the authentication of the user's phone number; pass null to use default settings
Settings *PhoneNumberAuthenticationSettings `json:"settings"`
}
// Sends a code to verify a phone number to be added to a user's Telegram Passport
func (client *Client) SendPhoneNumberVerificationCode(req *SendPhoneNumberVerificationCodeRequest) (*AuthenticationCodeInfo, error) {
result, err := client.Send(Request{
meta: meta{
Type: "sendPhoneNumberVerificationCode",
},
Data: map[string]interface{}{
"phone_number": req.PhoneNumber,
"settings": req.Settings,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalAuthenticationCodeInfo(result.Data)
}
// Re-sends the code to verify a phone number to be added to a user's Telegram Passport
func (client *Client) ResendPhoneNumberVerificationCode() (*AuthenticationCodeInfo, error) {
result, err := client.Send(Request{
meta: meta{
Type: "resendPhoneNumberVerificationCode",
},
Data: map[string]interface{}{},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalAuthenticationCodeInfo(result.Data)
}
type CheckPhoneNumberVerificationCodeRequest struct {
// Verification code to check
Code string `json:"code"`
}
// Checks the phone number verification code for Telegram Passport
func (client *Client) CheckPhoneNumberVerificationCode(req *CheckPhoneNumberVerificationCodeRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "checkPhoneNumberVerificationCode",
},
Data: map[string]interface{}{
"code": req.Code,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type SendEmailAddressVerificationCodeRequest struct {
// Email address
EmailAddress string `json:"email_address"`
}
// Sends a code to verify an email address to be added to a user's Telegram Passport
func (client *Client) SendEmailAddressVerificationCode(req *SendEmailAddressVerificationCodeRequest) (*EmailAddressAuthenticationCodeInfo, error) {
result, err := client.Send(Request{
meta: meta{
Type: "sendEmailAddressVerificationCode",
},
Data: map[string]interface{}{
"email_address": req.EmailAddress,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalEmailAddressAuthenticationCodeInfo(result.Data)
}
// Re-sends the code to verify an email address to be added to a user's Telegram Passport
func (client *Client) ResendEmailAddressVerificationCode() (*EmailAddressAuthenticationCodeInfo, error) {
result, err := client.Send(Request{
meta: meta{
Type: "resendEmailAddressVerificationCode",
},
Data: map[string]interface{}{},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalEmailAddressAuthenticationCodeInfo(result.Data)
}
type CheckEmailAddressVerificationCodeRequest struct {
// Verification code to check
Code string `json:"code"`
}
// Checks the email address verification code for Telegram Passport
func (client *Client) CheckEmailAddressVerificationCode(req *CheckEmailAddressVerificationCodeRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "checkEmailAddressVerificationCode",
},
Data: map[string]interface{}{
"code": req.Code,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type GetPassportAuthorizationFormRequest struct {
// User identifier of the service's bot
BotUserId int64 `json:"bot_user_id"`
// Telegram Passport element types requested by the service
Scope string `json:"scope"`
// Service's public key
PublicKey string `json:"public_key"`
// Unique request identifier provided by the service
Nonce string `json:"nonce"`
}
// Returns a Telegram Passport authorization form for sharing data with a service
func (client *Client) GetPassportAuthorizationForm(req *GetPassportAuthorizationFormRequest) (*PassportAuthorizationForm, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getPassportAuthorizationForm",
},
Data: map[string]interface{}{
"bot_user_id": req.BotUserId,
"scope": req.Scope,
"public_key": req.PublicKey,
"nonce": req.Nonce,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalPassportAuthorizationForm(result.Data)
}
type GetPassportAuthorizationFormAvailableElementsRequest struct {
// Authorization form identifier
AutorizationFormId int32 `json:"autorization_form_id"`
// Password of the current user
Password string `json:"password"`
}
// Returns already available Telegram Passport elements suitable for completing a Telegram Passport authorization form. Result can be received only once for each authorization form
func (client *Client) GetPassportAuthorizationFormAvailableElements(req *GetPassportAuthorizationFormAvailableElementsRequest) (*PassportElementsWithErrors, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getPassportAuthorizationFormAvailableElements",
},
Data: map[string]interface{}{
"autorization_form_id": req.AutorizationFormId,
"password": req.Password,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalPassportElementsWithErrors(result.Data)
}
type SendPassportAuthorizationFormRequest struct {
// Authorization form identifier
AutorizationFormId int32 `json:"autorization_form_id"`
// Types of Telegram Passport elements chosen by user to complete the authorization form
Types []PassportElementType `json:"types"`
}
// Sends a Telegram Passport authorization form, effectively sharing data with the service. This method must be called after getPassportAuthorizationFormAvailableElements if some previously available elements are going to be reused
func (client *Client) SendPassportAuthorizationForm(req *SendPassportAuthorizationFormRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "sendPassportAuthorizationForm",
},
Data: map[string]interface{}{
"autorization_form_id": req.AutorizationFormId,
"types": req.Types,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type SendPhoneNumberConfirmationCodeRequest struct {
// Hash value from the link
Hash string `json:"hash"`
// Phone number value from the link
PhoneNumber string `json:"phone_number"`
// Settings for the authentication of the user's phone number; pass null to use default settings
Settings *PhoneNumberAuthenticationSettings `json:"settings"`
}
// Sends phone number confirmation code to handle links of the type internalLinkTypePhoneNumberConfirmation
func (client *Client) SendPhoneNumberConfirmationCode(req *SendPhoneNumberConfirmationCodeRequest) (*AuthenticationCodeInfo, error) {
result, err := client.Send(Request{
meta: meta{
Type: "sendPhoneNumberConfirmationCode",
},
Data: map[string]interface{}{
"hash": req.Hash,
"phone_number": req.PhoneNumber,
"settings": req.Settings,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalAuthenticationCodeInfo(result.Data)
}
// Resends phone number confirmation code
func (client *Client) ResendPhoneNumberConfirmationCode() (*AuthenticationCodeInfo, error) {
result, err := client.Send(Request{
meta: meta{
Type: "resendPhoneNumberConfirmationCode",
},
Data: map[string]interface{}{},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalAuthenticationCodeInfo(result.Data)
}
type CheckPhoneNumberConfirmationCodeRequest struct {
// Confirmation code to check
Code string `json:"code"`
}
// Checks phone number confirmation code
func (client *Client) CheckPhoneNumberConfirmationCode(req *CheckPhoneNumberConfirmationCodeRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "checkPhoneNumberConfirmationCode",
},
Data: map[string]interface{}{
"code": req.Code,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type SetBotUpdatesStatusRequest struct {
// The number of pending updates
PendingUpdateCount int32 `json:"pending_update_count"`
// The last error message
ErrorMessage string `json:"error_message"`
}
// Informs the server about the number of pending bot updates if they haven't been processed for a long time; for bots only
func (client *Client) SetBotUpdatesStatus(req *SetBotUpdatesStatusRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "setBotUpdatesStatus",
},
Data: map[string]interface{}{
"pending_update_count": req.PendingUpdateCount,
"error_message": req.ErrorMessage,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type UploadStickerFileRequest struct {
// Sticker file owner; ignored for regular users
UserId int64 `json:"user_id"`
// Sticker file to upload
Sticker *InputSticker `json:"sticker"`
}
// Uploads a file with a sticker; returns the uploaded file
func (client *Client) UploadStickerFile(req *UploadStickerFileRequest) (*File, error) {
result, err := client.Send(Request{
meta: meta{
Type: "uploadStickerFile",
},
Data: map[string]interface{}{
"user_id": req.UserId,
"sticker": req.Sticker,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalFile(result.Data)
}
type GetSuggestedStickerSetNameRequest struct {
// Sticker set title; 1-64 characters
Title string `json:"title"`
}
// Returns a suggested name for a new sticker set with a given title
func (client *Client) GetSuggestedStickerSetName(req *GetSuggestedStickerSetNameRequest) (*Text, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getSuggestedStickerSetName",
},
Data: map[string]interface{}{
"title": req.Title,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalText(result.Data)
}
type CheckStickerSetNameRequest struct {
// Name to be checked
Name string `json:"name"`
}
// Checks whether a name can be used for a new sticker set
func (client *Client) CheckStickerSetName(req *CheckStickerSetNameRequest) (CheckStickerSetNameResult, error) {
result, err := client.Send(Request{
meta: meta{
Type: "checkStickerSetName",
},
Data: map[string]interface{}{
"name": req.Name,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
switch result.Type {
case TypeCheckStickerSetNameResultOk:
return UnmarshalCheckStickerSetNameResultOk(result.Data)
case TypeCheckStickerSetNameResultNameInvalid:
return UnmarshalCheckStickerSetNameResultNameInvalid(result.Data)
case TypeCheckStickerSetNameResultNameOccupied:
return UnmarshalCheckStickerSetNameResultNameOccupied(result.Data)
default:
return nil, errors.New("invalid type")
}
}
type CreateNewStickerSetRequest struct {
// Sticker set owner; ignored for regular users
UserId int64 `json:"user_id"`
// Sticker set title; 1-64 characters
Title string `json:"title"`
// Sticker set name. Can contain only English letters, digits and underscores. Must end with *"_by_<bot username>"* (*<bot_username>* is case insensitive) for bots; 1-64 characters
Name string `json:"name"`
// List of stickers to be added to the set; must be non-empty. All stickers must have the same format. For TGS stickers, uploadStickerFile must be used before the sticker is shown
Stickers []*InputSticker `json:"stickers"`
// Source of the sticker set; may be empty if unknown
Source string `json:"source"`
}
// Creates a new sticker set. Returns the newly created sticker set
func (client *Client) CreateNewStickerSet(req *CreateNewStickerSetRequest) (*StickerSet, error) {
result, err := client.Send(Request{
meta: meta{
Type: "createNewStickerSet",
},
Data: map[string]interface{}{
"user_id": req.UserId,
"title": req.Title,
"name": req.Name,
"stickers": req.Stickers,
"source": req.Source,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalStickerSet(result.Data)
}
type AddStickerToSetRequest struct {
// Sticker set owner
UserId int64 `json:"user_id"`
// Sticker set name
Name string `json:"name"`
// Sticker to add to the set
Sticker *InputSticker `json:"sticker"`
}
// Adds a new sticker to a set; for bots only. Returns the sticker set
func (client *Client) AddStickerToSet(req *AddStickerToSetRequest) (*StickerSet, error) {
result, err := client.Send(Request{
meta: meta{
Type: "addStickerToSet",
},
Data: map[string]interface{}{
"user_id": req.UserId,
"name": req.Name,
"sticker": req.Sticker,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalStickerSet(result.Data)
}
type SetStickerSetThumbnailRequest struct {
// Sticker set owner
UserId int64 `json:"user_id"`
// Sticker set name
Name string `json:"name"`
// Thumbnail to set in PNG, TGS, or WEBM format; pass null to remove the sticker set thumbnail. Thumbnail format must match the format of stickers in the set
Thumbnail InputFile `json:"thumbnail"`
}
// Sets a sticker set thumbnail; for bots only. Returns the sticker set
func (client *Client) SetStickerSetThumbnail(req *SetStickerSetThumbnailRequest) (*StickerSet, error) {
result, err := client.Send(Request{
meta: meta{
Type: "setStickerSetThumbnail",
},
Data: map[string]interface{}{
"user_id": req.UserId,
"name": req.Name,
"thumbnail": req.Thumbnail,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalStickerSet(result.Data)
}
type SetStickerPositionInSetRequest struct {
// Sticker
Sticker InputFile `json:"sticker"`
// New position of the sticker in the set, zero-based
Position int32 `json:"position"`
}
// Changes the position of a sticker in the set to which it belongs; for bots only. The sticker set must have been created by the bot
func (client *Client) SetStickerPositionInSet(req *SetStickerPositionInSetRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "setStickerPositionInSet",
},
Data: map[string]interface{}{
"sticker": req.Sticker,
"position": req.Position,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type RemoveStickerFromSetRequest struct {
// Sticker
Sticker InputFile `json:"sticker"`
}
// Removes a sticker from the set to which it belongs; for bots only. The sticker set must have been created by the bot
func (client *Client) RemoveStickerFromSet(req *RemoveStickerFromSetRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "removeStickerFromSet",
},
Data: map[string]interface{}{
"sticker": req.Sticker,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type GetMapThumbnailFileRequest struct {
// Location of the map center
Location *Location `json:"location"`
// Map zoom level; 13-20
Zoom int32 `json:"zoom"`
// Map width in pixels before applying scale; 16-1024
Width int32 `json:"width"`
// Map height in pixels before applying scale; 16-1024
Height int32 `json:"height"`
// Map scale; 1-3
Scale int32 `json:"scale"`
// Identifier of a chat in which the thumbnail will be shown. Use 0 if unknown
ChatId int64 `json:"chat_id"`
}
// Returns information about a file with a map thumbnail in PNG format. Only map thumbnail files with size less than 1MB can be downloaded
func (client *Client) GetMapThumbnailFile(req *GetMapThumbnailFileRequest) (*File, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getMapThumbnailFile",
},
Data: map[string]interface{}{
"location": req.Location,
"zoom": req.Zoom,
"width": req.Width,
"height": req.Height,
"scale": req.Scale,
"chat_id": req.ChatId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalFile(result.Data)
}
type AcceptTermsOfServiceRequest struct {
// Terms of service identifier
TermsOfServiceId string `json:"terms_of_service_id"`
}
// Accepts Telegram terms of services
func (client *Client) AcceptTermsOfService(req *AcceptTermsOfServiceRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "acceptTermsOfService",
},
Data: map[string]interface{}{
"terms_of_service_id": req.TermsOfServiceId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type SendCustomRequestRequest struct {
// The method name
Method string `json:"method"`
// JSON-serialized method parameters
Parameters string `json:"parameters"`
}
// Sends a custom request; for bots only
func (client *Client) SendCustomRequest(req *SendCustomRequestRequest) (*CustomRequestResult, error) {
result, err := client.Send(Request{
meta: meta{
Type: "sendCustomRequest",
},
Data: map[string]interface{}{
"method": req.Method,
"parameters": req.Parameters,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalCustomRequestResult(result.Data)
}
type AnswerCustomQueryRequest struct {
// Identifier of a custom query
CustomQueryId JsonInt64 `json:"custom_query_id"`
// JSON-serialized answer to the query
Data string `json:"data"`
}
// Answers a custom query; for bots only
func (client *Client) AnswerCustomQuery(req *AnswerCustomQueryRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "answerCustomQuery",
},
Data: map[string]interface{}{
"custom_query_id": req.CustomQueryId,
"data": req.Data,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type SetAlarmRequest struct {
// Number of seconds before the function returns
Seconds float64 `json:"seconds"`
}
// Succeeds after a specified amount of time has passed. Can be called before initialization
func (client *Client) SetAlarm(req *SetAlarmRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "setAlarm",
},
Data: map[string]interface{}{
"seconds": req.Seconds,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
// Returns information about existing countries. Can be called before authorization
func (client *Client) GetCountries() (*Countries, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getCountries",
},
Data: map[string]interface{}{},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalCountries(result.Data)
}
// Uses the current IP address to find the current country. Returns two-letter ISO 3166-1 alpha-2 country code. Can be called before authorization
func (client *Client) GetCountryCode() (*Text, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getCountryCode",
},
Data: map[string]interface{}{},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalText(result.Data)
}
type GetPhoneNumberInfoRequest struct {
// The phone number prefix
PhoneNumberPrefix string `json:"phone_number_prefix"`
}
// Returns information about a phone number by its prefix. Can be called before authorization
func (client *Client) GetPhoneNumberInfo(req *GetPhoneNumberInfoRequest) (*PhoneNumberInfo, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getPhoneNumberInfo",
},
Data: map[string]interface{}{
"phone_number_prefix": req.PhoneNumberPrefix,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalPhoneNumberInfo(result.Data)
}
type GetPhoneNumberInfoSyncRequest struct {
// A two-letter ISO 639-1 language code for country information localization
LanguageCode string `json:"language_code"`
// The phone number prefix
PhoneNumberPrefix string `json:"phone_number_prefix"`
}
// Returns information about a phone number by its prefix synchronously. getCountries must be called at least once after changing localization to the specified language if properly localized country information is expected. Can be called synchronously
func GetPhoneNumberInfoSync(req *GetPhoneNumberInfoSyncRequest) (*PhoneNumberInfo, error) {
result, err := Execute(Request{
meta: meta{
Type: "getPhoneNumberInfoSync",
},
Data: map[string]interface{}{
"language_code": req.LanguageCode,
"phone_number_prefix": req.PhoneNumberPrefix,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalPhoneNumberInfo(result.Data)
}
// deprecated
// Returns information about a phone number by its prefix synchronously. getCountries must be called at least once after changing localization to the specified language if properly localized country information is expected. Can be called synchronously
func (client *Client) GetPhoneNumberInfoSync(req *GetPhoneNumberInfoSyncRequest) (*PhoneNumberInfo, error) {
return GetPhoneNumberInfoSync(req)}
// Returns the link for downloading official Telegram application to be used when the current user invites friends to Telegram
func (client *Client) GetApplicationDownloadLink() (*HttpUrl, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getApplicationDownloadLink",
},
Data: map[string]interface{}{},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalHttpUrl(result.Data)
}
type GetDeepLinkInfoRequest struct {
// The link
Link string `json:"link"`
}
// Returns information about a tg:// deep link. Use "tg://need_update_for_some_feature" or "tg:some_unsupported_feature" for testing. Returns a 404 error for unknown links. Can be called before authorization
func (client *Client) GetDeepLinkInfo(req *GetDeepLinkInfoRequest) (*DeepLinkInfo, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getDeepLinkInfo",
},
Data: map[string]interface{}{
"link": req.Link,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalDeepLinkInfo(result.Data)
}
// Returns application config, provided by the server. Can be called before authorization
func (client *Client) GetApplicationConfig() (JsonValue, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getApplicationConfig",
},
Data: map[string]interface{}{},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
switch result.Type {
case TypeJsonValueNull:
return UnmarshalJsonValueNull(result.Data)
case TypeJsonValueBoolean:
return UnmarshalJsonValueBoolean(result.Data)
case TypeJsonValueNumber:
return UnmarshalJsonValueNumber(result.Data)
case TypeJsonValueString:
return UnmarshalJsonValueString(result.Data)
case TypeJsonValueArray:
return UnmarshalJsonValueArray(result.Data)
case TypeJsonValueObject:
return UnmarshalJsonValueObject(result.Data)
default:
return nil, errors.New("invalid type")
}
}
type SaveApplicationLogEventRequest struct {
// Event type
Type string `json:"type"`
// Optional chat identifier, associated with the event
ChatId int64 `json:"chat_id"`
// The log event data
Data JsonValue `json:"data"`
}
// Saves application log event on the server. Can be called before authorization
func (client *Client) SaveApplicationLogEvent(req *SaveApplicationLogEventRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "saveApplicationLogEvent",
},
Data: map[string]interface{}{
"type": req.Type,
"chat_id": req.ChatId,
"data": req.Data,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type AddProxyRequest struct {
// Proxy server IP address
Server string `json:"server"`
// Proxy server port
Port int32 `json:"port"`
// Pass true to immediately enable the proxy
Enable bool `json:"enable"`
// Proxy type
Type ProxyType `json:"type"`
}
// Adds a proxy server for network requests. Can be called before authorization
func (client *Client) AddProxy(req *AddProxyRequest) (*Proxy, error) {
result, err := client.Send(Request{
meta: meta{
Type: "addProxy",
},
Data: map[string]interface{}{
"server": req.Server,
"port": req.Port,
"enable": req.Enable,
"type": req.Type,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalProxy(result.Data)
}
type EditProxyRequest struct {
// Proxy identifier
ProxyId int32 `json:"proxy_id"`
// Proxy server IP address
Server string `json:"server"`
// Proxy server port
Port int32 `json:"port"`
// Pass true to immediately enable the proxy
Enable bool `json:"enable"`
// Proxy type
Type ProxyType `json:"type"`
}
// Edits an existing proxy server for network requests. Can be called before authorization
func (client *Client) EditProxy(req *EditProxyRequest) (*Proxy, error) {
result, err := client.Send(Request{
meta: meta{
Type: "editProxy",
},
Data: map[string]interface{}{
"proxy_id": req.ProxyId,
"server": req.Server,
"port": req.Port,
"enable": req.Enable,
"type": req.Type,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalProxy(result.Data)
}
type EnableProxyRequest struct {
// Proxy identifier
ProxyId int32 `json:"proxy_id"`
}
// Enables a proxy. Only one proxy can be enabled at a time. Can be called before authorization
func (client *Client) EnableProxy(req *EnableProxyRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "enableProxy",
},
Data: map[string]interface{}{
"proxy_id": req.ProxyId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
// Disables the currently enabled proxy. Can be called before authorization
func (client *Client) DisableProxy() (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "disableProxy",
},
Data: map[string]interface{}{},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type RemoveProxyRequest struct {
// Proxy identifier
ProxyId int32 `json:"proxy_id"`
}
// Removes a proxy server. Can be called before authorization
func (client *Client) RemoveProxy(req *RemoveProxyRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "removeProxy",
},
Data: map[string]interface{}{
"proxy_id": req.ProxyId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
// Returns list of proxies that are currently set up. Can be called before authorization
func (client *Client) GetProxies() (*Proxies, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getProxies",
},
Data: map[string]interface{}{},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalProxies(result.Data)
}
type GetProxyLinkRequest struct {
// Proxy identifier
ProxyId int32 `json:"proxy_id"`
}
// Returns an HTTPS link, which can be used to add a proxy. Available only for SOCKS5 and MTProto proxies. Can be called before authorization
func (client *Client) GetProxyLink(req *GetProxyLinkRequest) (*HttpUrl, error) {
result, err := client.Send(Request{
meta: meta{
Type: "getProxyLink",
},
Data: map[string]interface{}{
"proxy_id": req.ProxyId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalHttpUrl(result.Data)
}
type PingProxyRequest struct {
// Proxy identifier. Use 0 to ping a Telegram server without a proxy
ProxyId int32 `json:"proxy_id"`
}
// Computes time needed to receive a response from a Telegram server through a proxy. Can be called before authorization
func (client *Client) PingProxy(req *PingProxyRequest) (*Seconds, error) {
result, err := client.Send(Request{
meta: meta{
Type: "pingProxy",
},
Data: map[string]interface{}{
"proxy_id": req.ProxyId,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalSeconds(result.Data)
}
type SetLogStreamRequest struct {
// New log stream
LogStream LogStream `json:"log_stream"`
}
// Sets new log stream for internal logging of TDLib. Can be called synchronously
func SetLogStream(req *SetLogStreamRequest) (*Ok, error) {
result, err := Execute(Request{
meta: meta{
Type: "setLogStream",
},
Data: map[string]interface{}{
"log_stream": req.LogStream,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
// deprecated
// Sets new log stream for internal logging of TDLib. Can be called synchronously
func (client *Client) SetLogStream(req *SetLogStreamRequest) (*Ok, error) {
return SetLogStream(req)}
// Returns information about currently used log stream for internal logging of TDLib. Can be called synchronously
func GetLogStream() (LogStream, error) {
result, err := Execute(Request{
meta: meta{
Type: "getLogStream",
},
Data: map[string]interface{}{},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
switch result.Type {
case TypeLogStreamDefault:
return UnmarshalLogStreamDefault(result.Data)
case TypeLogStreamFile:
return UnmarshalLogStreamFile(result.Data)
case TypeLogStreamEmpty:
return UnmarshalLogStreamEmpty(result.Data)
default:
return nil, errors.New("invalid type")
}
}
// deprecated
// Returns information about currently used log stream for internal logging of TDLib. Can be called synchronously
func (client *Client) GetLogStream() (LogStream, error) {
return GetLogStream()}
type SetLogVerbosityLevelRequest struct {
// New value of the verbosity level for logging. Value 0 corresponds to fatal errors, value 1 corresponds to errors, value 2 corresponds to warnings and debug warnings, value 3 corresponds to informational, value 4 corresponds to debug, value 5 corresponds to verbose debug, value greater than 5 and up to 1023 can be used to enable even more logging
NewVerbosityLevel int32 `json:"new_verbosity_level"`
}
// Sets the verbosity level of the internal logging of TDLib. Can be called synchronously
func SetLogVerbosityLevel(req *SetLogVerbosityLevelRequest) (*Ok, error) {
result, err := Execute(Request{
meta: meta{
Type: "setLogVerbosityLevel",
},
Data: map[string]interface{}{
"new_verbosity_level": req.NewVerbosityLevel,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
// deprecated
// Sets the verbosity level of the internal logging of TDLib. Can be called synchronously
func (client *Client) SetLogVerbosityLevel(req *SetLogVerbosityLevelRequest) (*Ok, error) {
return SetLogVerbosityLevel(req)}
// Returns current verbosity level of the internal logging of TDLib. Can be called synchronously
func GetLogVerbosityLevel() (*LogVerbosityLevel, error) {
result, err := Execute(Request{
meta: meta{
Type: "getLogVerbosityLevel",
},
Data: map[string]interface{}{},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalLogVerbosityLevel(result.Data)
}
// deprecated
// Returns current verbosity level of the internal logging of TDLib. Can be called synchronously
func (client *Client) GetLogVerbosityLevel() (*LogVerbosityLevel, error) {
return GetLogVerbosityLevel()}
// Returns list of available TDLib internal log tags, for example, ["actor", "binlog", "connections", "notifications", "proxy"]. Can be called synchronously
func GetLogTags() (*LogTags, error) {
result, err := Execute(Request{
meta: meta{
Type: "getLogTags",
},
Data: map[string]interface{}{},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalLogTags(result.Data)
}
// deprecated
// Returns list of available TDLib internal log tags, for example, ["actor", "binlog", "connections", "notifications", "proxy"]. Can be called synchronously
func (client *Client) GetLogTags() (*LogTags, error) {
return GetLogTags()}
type SetLogTagVerbosityLevelRequest struct {
// Logging tag to change verbosity level
Tag string `json:"tag"`
// New verbosity level; 1-1024
NewVerbosityLevel int32 `json:"new_verbosity_level"`
}
// Sets the verbosity level for a specified TDLib internal log tag. Can be called synchronously
func SetLogTagVerbosityLevel(req *SetLogTagVerbosityLevelRequest) (*Ok, error) {
result, err := Execute(Request{
meta: meta{
Type: "setLogTagVerbosityLevel",
},
Data: map[string]interface{}{
"tag": req.Tag,
"new_verbosity_level": req.NewVerbosityLevel,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
// deprecated
// Sets the verbosity level for a specified TDLib internal log tag. Can be called synchronously
func (client *Client) SetLogTagVerbosityLevel(req *SetLogTagVerbosityLevelRequest) (*Ok, error) {
return SetLogTagVerbosityLevel(req)}
type GetLogTagVerbosityLevelRequest struct {
// Logging tag to change verbosity level
Tag string `json:"tag"`
}
// Returns current verbosity level for a specified TDLib internal log tag. Can be called synchronously
func GetLogTagVerbosityLevel(req *GetLogTagVerbosityLevelRequest) (*LogVerbosityLevel, error) {
result, err := Execute(Request{
meta: meta{
Type: "getLogTagVerbosityLevel",
},
Data: map[string]interface{}{
"tag": req.Tag,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalLogVerbosityLevel(result.Data)
}
// deprecated
// Returns current verbosity level for a specified TDLib internal log tag. Can be called synchronously
func (client *Client) GetLogTagVerbosityLevel(req *GetLogTagVerbosityLevelRequest) (*LogVerbosityLevel, error) {
return GetLogTagVerbosityLevel(req)}
type AddLogMessageRequest struct {
// The minimum verbosity level needed for the message to be logged; 0-1023
VerbosityLevel int32 `json:"verbosity_level"`
// Text of a message to log
Text string `json:"text"`
}
// Adds a message to TDLib internal log. Can be called synchronously
func AddLogMessage(req *AddLogMessageRequest) (*Ok, error) {
result, err := Execute(Request{
meta: meta{
Type: "addLogMessage",
},
Data: map[string]interface{}{
"verbosity_level": req.VerbosityLevel,
"text": req.Text,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
// deprecated
// Adds a message to TDLib internal log. Can be called synchronously
func (client *Client) AddLogMessage(req *AddLogMessageRequest) (*Ok, error) {
return AddLogMessage(req)}
// Does nothing; for testing only. This is an offline method. Can be called before authorization
func (client *Client) TestCallEmpty() (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "testCallEmpty",
},
Data: map[string]interface{}{},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type TestCallStringRequest struct {
// String to return
X string `json:"x"`
}
// Returns the received string; for testing only. This is an offline method. Can be called before authorization
func (client *Client) TestCallString(req *TestCallStringRequest) (*TestString, error) {
result, err := client.Send(Request{
meta: meta{
Type: "testCallString",
},
Data: map[string]interface{}{
"x": req.X,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalTestString(result.Data)
}
type TestCallBytesRequest struct {
// Bytes to return
X []byte `json:"x"`
}
// Returns the received bytes; for testing only. This is an offline method. Can be called before authorization
func (client *Client) TestCallBytes(req *TestCallBytesRequest) (*TestBytes, error) {
result, err := client.Send(Request{
meta: meta{
Type: "testCallBytes",
},
Data: map[string]interface{}{
"x": req.X,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalTestBytes(result.Data)
}
type TestCallVectorIntRequest struct {
// Vector of numbers to return
X []int32 `json:"x"`
}
// Returns the received vector of numbers; for testing only. This is an offline method. Can be called before authorization
func (client *Client) TestCallVectorInt(req *TestCallVectorIntRequest) (*TestVectorInt, error) {
result, err := client.Send(Request{
meta: meta{
Type: "testCallVectorInt",
},
Data: map[string]interface{}{
"x": req.X,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalTestVectorInt(result.Data)
}
type TestCallVectorIntObjectRequest struct {
// Vector of objects to return
X []*TestInt `json:"x"`
}
// Returns the received vector of objects containing a number; for testing only. This is an offline method. Can be called before authorization
func (client *Client) TestCallVectorIntObject(req *TestCallVectorIntObjectRequest) (*TestVectorIntObject, error) {
result, err := client.Send(Request{
meta: meta{
Type: "testCallVectorIntObject",
},
Data: map[string]interface{}{
"x": req.X,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalTestVectorIntObject(result.Data)
}
type TestCallVectorStringRequest struct {
// Vector of strings to return
X []string `json:"x"`
}
// Returns the received vector of strings; for testing only. This is an offline method. Can be called before authorization
func (client *Client) TestCallVectorString(req *TestCallVectorStringRequest) (*TestVectorString, error) {
result, err := client.Send(Request{
meta: meta{
Type: "testCallVectorString",
},
Data: map[string]interface{}{
"x": req.X,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalTestVectorString(result.Data)
}
type TestCallVectorStringObjectRequest struct {
// Vector of objects to return
X []*TestString `json:"x"`
}
// Returns the received vector of objects containing a string; for testing only. This is an offline method. Can be called before authorization
func (client *Client) TestCallVectorStringObject(req *TestCallVectorStringObjectRequest) (*TestVectorStringObject, error) {
result, err := client.Send(Request{
meta: meta{
Type: "testCallVectorStringObject",
},
Data: map[string]interface{}{
"x": req.X,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalTestVectorStringObject(result.Data)
}
type TestSquareIntRequest struct {
// Number to square
X int32 `json:"x"`
}
// Returns the squared received number; for testing only. This is an offline method. Can be called before authorization
func (client *Client) TestSquareInt(req *TestSquareIntRequest) (*TestInt, error) {
result, err := client.Send(Request{
meta: meta{
Type: "testSquareInt",
},
Data: map[string]interface{}{
"x": req.X,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalTestInt(result.Data)
}
// Sends a simple network request to the Telegram servers; for testing only. Can be called before authorization
func (client *Client) TestNetwork() (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "testNetwork",
},
Data: map[string]interface{}{},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
type TestProxyRequest struct {
// Proxy server IP address
Server string `json:"server"`
// Proxy server port
Port int32 `json:"port"`
// Proxy type
Type ProxyType `json:"type"`
// Identifier of a datacenter with which to test connection
DcId int32 `json:"dc_id"`
// The maximum overall timeout for the request
Timeout float64 `json:"timeout"`
}
// Sends a simple network request to the Telegram servers via proxy; for testing only. Can be called before authorization
func (client *Client) TestProxy(req *TestProxyRequest) (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "testProxy",
},
Data: map[string]interface{}{
"server": req.Server,
"port": req.Port,
"type": req.Type,
"dc_id": req.DcId,
"timeout": req.Timeout,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
// Forces an updates.getDifference call to the Telegram servers; for testing only
func (client *Client) TestGetDifference() (*Ok, error) {
result, err := client.Send(Request{
meta: meta{
Type: "testGetDifference",
},
Data: map[string]interface{}{},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalOk(result.Data)
}
// Does nothing and ensures that the Update object is used; for testing only. This is an offline method. Can be called before authorization
func (client *Client) TestUseUpdate() (Update, error) {
result, err := client.Send(Request{
meta: meta{
Type: "testUseUpdate",
},
Data: map[string]interface{}{},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
switch result.Type {
case TypeUpdateAuthorizationState:
return UnmarshalUpdateAuthorizationState(result.Data)
case TypeUpdateNewMessage:
return UnmarshalUpdateNewMessage(result.Data)
case TypeUpdateMessageSendAcknowledged:
return UnmarshalUpdateMessageSendAcknowledged(result.Data)
case TypeUpdateMessageSendSucceeded:
return UnmarshalUpdateMessageSendSucceeded(result.Data)
case TypeUpdateMessageSendFailed:
return UnmarshalUpdateMessageSendFailed(result.Data)
case TypeUpdateMessageContent:
return UnmarshalUpdateMessageContent(result.Data)
case TypeUpdateMessageEdited:
return UnmarshalUpdateMessageEdited(result.Data)
case TypeUpdateMessageIsPinned:
return UnmarshalUpdateMessageIsPinned(result.Data)
case TypeUpdateMessageInteractionInfo:
return UnmarshalUpdateMessageInteractionInfo(result.Data)
case TypeUpdateMessageContentOpened:
return UnmarshalUpdateMessageContentOpened(result.Data)
case TypeUpdateMessageMentionRead:
return UnmarshalUpdateMessageMentionRead(result.Data)
case TypeUpdateMessageUnreadReactions:
return UnmarshalUpdateMessageUnreadReactions(result.Data)
case TypeUpdateMessageLiveLocationViewed:
return UnmarshalUpdateMessageLiveLocationViewed(result.Data)
case TypeUpdateNewChat:
return UnmarshalUpdateNewChat(result.Data)
case TypeUpdateChatTitle:
return UnmarshalUpdateChatTitle(result.Data)
case TypeUpdateChatPhoto:
return UnmarshalUpdateChatPhoto(result.Data)
case TypeUpdateChatPermissions:
return UnmarshalUpdateChatPermissions(result.Data)
case TypeUpdateChatLastMessage:
return UnmarshalUpdateChatLastMessage(result.Data)
case TypeUpdateChatPosition:
return UnmarshalUpdateChatPosition(result.Data)
case TypeUpdateChatReadInbox:
return UnmarshalUpdateChatReadInbox(result.Data)
case TypeUpdateChatReadOutbox:
return UnmarshalUpdateChatReadOutbox(result.Data)
case TypeUpdateChatActionBar:
return UnmarshalUpdateChatActionBar(result.Data)
case TypeUpdateChatAvailableReactions:
return UnmarshalUpdateChatAvailableReactions(result.Data)
case TypeUpdateChatDraftMessage:
return UnmarshalUpdateChatDraftMessage(result.Data)
case TypeUpdateChatMessageSender:
return UnmarshalUpdateChatMessageSender(result.Data)
case TypeUpdateChatMessageTtl:
return UnmarshalUpdateChatMessageTtl(result.Data)
case TypeUpdateChatNotificationSettings:
return UnmarshalUpdateChatNotificationSettings(result.Data)
case TypeUpdateChatPendingJoinRequests:
return UnmarshalUpdateChatPendingJoinRequests(result.Data)
case TypeUpdateChatReplyMarkup:
return UnmarshalUpdateChatReplyMarkup(result.Data)
case TypeUpdateChatTheme:
return UnmarshalUpdateChatTheme(result.Data)
case TypeUpdateChatUnreadMentionCount:
return UnmarshalUpdateChatUnreadMentionCount(result.Data)
case TypeUpdateChatUnreadReactionCount:
return UnmarshalUpdateChatUnreadReactionCount(result.Data)
case TypeUpdateChatVideoChat:
return UnmarshalUpdateChatVideoChat(result.Data)
case TypeUpdateChatDefaultDisableNotification:
return UnmarshalUpdateChatDefaultDisableNotification(result.Data)
case TypeUpdateChatHasProtectedContent:
return UnmarshalUpdateChatHasProtectedContent(result.Data)
case TypeUpdateChatHasScheduledMessages:
return UnmarshalUpdateChatHasScheduledMessages(result.Data)
case TypeUpdateChatIsBlocked:
return UnmarshalUpdateChatIsBlocked(result.Data)
case TypeUpdateChatIsMarkedAsUnread:
return UnmarshalUpdateChatIsMarkedAsUnread(result.Data)
case TypeUpdateChatFilters:
return UnmarshalUpdateChatFilters(result.Data)
case TypeUpdateChatOnlineMemberCount:
return UnmarshalUpdateChatOnlineMemberCount(result.Data)
case TypeUpdateScopeNotificationSettings:
return UnmarshalUpdateScopeNotificationSettings(result.Data)
case TypeUpdateNotification:
return UnmarshalUpdateNotification(result.Data)
case TypeUpdateNotificationGroup:
return UnmarshalUpdateNotificationGroup(result.Data)
case TypeUpdateActiveNotifications:
return UnmarshalUpdateActiveNotifications(result.Data)
case TypeUpdateHavePendingNotifications:
return UnmarshalUpdateHavePendingNotifications(result.Data)
case TypeUpdateDeleteMessages:
return UnmarshalUpdateDeleteMessages(result.Data)
case TypeUpdateChatAction:
return UnmarshalUpdateChatAction(result.Data)
case TypeUpdateUserStatus:
return UnmarshalUpdateUserStatus(result.Data)
case TypeUpdateUser:
return UnmarshalUpdateUser(result.Data)
case TypeUpdateBasicGroup:
return UnmarshalUpdateBasicGroup(result.Data)
case TypeUpdateSupergroup:
return UnmarshalUpdateSupergroup(result.Data)
case TypeUpdateSecretChat:
return UnmarshalUpdateSecretChat(result.Data)
case TypeUpdateUserFullInfo:
return UnmarshalUpdateUserFullInfo(result.Data)
case TypeUpdateBasicGroupFullInfo:
return UnmarshalUpdateBasicGroupFullInfo(result.Data)
case TypeUpdateSupergroupFullInfo:
return UnmarshalUpdateSupergroupFullInfo(result.Data)
case TypeUpdateServiceNotification:
return UnmarshalUpdateServiceNotification(result.Data)
case TypeUpdateFile:
return UnmarshalUpdateFile(result.Data)
case TypeUpdateFileGenerationStart:
return UnmarshalUpdateFileGenerationStart(result.Data)
case TypeUpdateFileGenerationStop:
return UnmarshalUpdateFileGenerationStop(result.Data)
case TypeUpdateFileDownloads:
return UnmarshalUpdateFileDownloads(result.Data)
case TypeUpdateFileAddedToDownloads:
return UnmarshalUpdateFileAddedToDownloads(result.Data)
case TypeUpdateFileDownload:
return UnmarshalUpdateFileDownload(result.Data)
case TypeUpdateFileRemovedFromDownloads:
return UnmarshalUpdateFileRemovedFromDownloads(result.Data)
case TypeUpdateCall:
return UnmarshalUpdateCall(result.Data)
case TypeUpdateGroupCall:
return UnmarshalUpdateGroupCall(result.Data)
case TypeUpdateGroupCallParticipant:
return UnmarshalUpdateGroupCallParticipant(result.Data)
case TypeUpdateNewCallSignalingData:
return UnmarshalUpdateNewCallSignalingData(result.Data)
case TypeUpdateUserPrivacySettingRules:
return UnmarshalUpdateUserPrivacySettingRules(result.Data)
case TypeUpdateUnreadMessageCount:
return UnmarshalUpdateUnreadMessageCount(result.Data)
case TypeUpdateUnreadChatCount:
return UnmarshalUpdateUnreadChatCount(result.Data)
case TypeUpdateOption:
return UnmarshalUpdateOption(result.Data)
case TypeUpdateStickerSet:
return UnmarshalUpdateStickerSet(result.Data)
case TypeUpdateInstalledStickerSets:
return UnmarshalUpdateInstalledStickerSets(result.Data)
case TypeUpdateTrendingStickerSets:
return UnmarshalUpdateTrendingStickerSets(result.Data)
case TypeUpdateRecentStickers:
return UnmarshalUpdateRecentStickers(result.Data)
case TypeUpdateFavoriteStickers:
return UnmarshalUpdateFavoriteStickers(result.Data)
case TypeUpdateSavedAnimations:
return UnmarshalUpdateSavedAnimations(result.Data)
case TypeUpdateSavedNotificationSounds:
return UnmarshalUpdateSavedNotificationSounds(result.Data)
case TypeUpdateSelectedBackground:
return UnmarshalUpdateSelectedBackground(result.Data)
case TypeUpdateChatThemes:
return UnmarshalUpdateChatThemes(result.Data)
case TypeUpdateLanguagePackStrings:
return UnmarshalUpdateLanguagePackStrings(result.Data)
case TypeUpdateConnectionState:
return UnmarshalUpdateConnectionState(result.Data)
case TypeUpdateTermsOfService:
return UnmarshalUpdateTermsOfService(result.Data)
case TypeUpdateUsersNearby:
return UnmarshalUpdateUsersNearby(result.Data)
case TypeUpdateAttachmentMenuBots:
return UnmarshalUpdateAttachmentMenuBots(result.Data)
case TypeUpdateWebAppMessageSent:
return UnmarshalUpdateWebAppMessageSent(result.Data)
case TypeUpdateReactions:
return UnmarshalUpdateReactions(result.Data)
case TypeUpdateDiceEmojis:
return UnmarshalUpdateDiceEmojis(result.Data)
case TypeUpdateAnimatedEmojiMessageClicked:
return UnmarshalUpdateAnimatedEmojiMessageClicked(result.Data)
case TypeUpdateAnimationSearchParameters:
return UnmarshalUpdateAnimationSearchParameters(result.Data)
case TypeUpdateSuggestedActions:
return UnmarshalUpdateSuggestedActions(result.Data)
case TypeUpdateNewInlineQuery:
return UnmarshalUpdateNewInlineQuery(result.Data)
case TypeUpdateNewChosenInlineResult:
return UnmarshalUpdateNewChosenInlineResult(result.Data)
case TypeUpdateNewCallbackQuery:
return UnmarshalUpdateNewCallbackQuery(result.Data)
case TypeUpdateNewInlineCallbackQuery:
return UnmarshalUpdateNewInlineCallbackQuery(result.Data)
case TypeUpdateNewShippingQuery:
return UnmarshalUpdateNewShippingQuery(result.Data)
case TypeUpdateNewPreCheckoutQuery:
return UnmarshalUpdateNewPreCheckoutQuery(result.Data)
case TypeUpdateNewCustomEvent:
return UnmarshalUpdateNewCustomEvent(result.Data)
case TypeUpdateNewCustomQuery:
return UnmarshalUpdateNewCustomQuery(result.Data)
case TypeUpdatePoll:
return UnmarshalUpdatePoll(result.Data)
case TypeUpdatePollAnswer:
return UnmarshalUpdatePollAnswer(result.Data)
case TypeUpdateChatMember:
return UnmarshalUpdateChatMember(result.Data)
case TypeUpdateNewChatJoinRequest:
return UnmarshalUpdateNewChatJoinRequest(result.Data)
default:
return nil, errors.New("invalid type")
}
}
type TestReturnErrorRequest struct {
// The error to be returned
Error *Error `json:"error"`
}
// Returns the specified error and ensures that the Error object is used; for testing only. Can be called synchronously
func TestReturnError(req *TestReturnErrorRequest) (*Error, error) {
result, err := Execute(Request{
meta: meta{
Type: "testReturnError",
},
Data: map[string]interface{}{
"error": req.Error,
},
})
if err != nil {
return nil, err
}
if result.Type == "error" {
return nil, buildResponseError(result.Data)
}
return UnmarshalError(result.Data)
}
// deprecated
// Returns the specified error and ensures that the Error object is used; for testing only. Can be called synchronously
func (client *Client) TestReturnError(req *TestReturnErrorRequest) (*Error, error) {
return TestReturnError(req)}
Reference in a new issue View git blame Copy permalink