types.go

package utils

import (
	"github.com/dsurl/tgo"
	"github.com/dsurl/tgo/api"
)

// ID creates tgo.ChatID from user's identifier
func ID(id int64) tgo.ChatID {
	return tgo.ChatID{
		ID: id,
	}
}

// Username creates tgo.ChatID from username
func Username(username string) tgo.ChatID {
	return tgo.ChatID{
		Username: username,
	}
}

// File creates tgo.InputFile from api.NamedReader
func File(file api.NamedReader) tgo.InputFile {
	return tgo.InputFile{
		File: file,
	}
}

// FileByURL creates tgo.InputFile from URL
func FileByURL(url string) tgo.InputFile {
	return tgo.InputFile{
		URL: url,
	}
}

// FileByID creates tgo.InputFile from file ID
func FileByID(id string) tgo.InputFile {
	return tgo.InputFile{
		FileID: id,
	}
}

// Keyboard creates tgo.ReplyKeyboardMarkup from slice of keyboard buttons
func Keyboard(rows ...[]tgo.KeyboardButton) *tgo.ReplyKeyboardMarkup {
	return &tgo.ReplyKeyboardMarkup{
		Keyboard: rows,
	}
}

// KeyboardRow creates slice of tgo.KeyboardButton
func KeyboardRow(buttons ...tgo.KeyboardButton) []tgo.KeyboardButton {
	return buttons
}

// KeyboardButton creates tgo.KeyboardButton with required fields
func KeyboardButton(text string) tgo.KeyboardButton {
	return tgo.KeyboardButton{
		Text: text,
	}
}

// PollTypeAny creates tgo.KeyboardButtonPollType with any type
func PollTypeAny() *tgo.KeyboardButtonPollType {
	return &tgo.KeyboardButtonPollType{}
}

// PollTypeRegular creates tgo.KeyboardButtonPollType with type regular
func PollTypeRegular() *tgo.KeyboardButtonPollType {
	return &tgo.KeyboardButtonPollType{
		Type: tgo.PollTypeRegular,
	}
}

// PollTypeQuiz creates tgo.KeyboardButtonPollType with type quiz
func PollTypeQuiz() *tgo.KeyboardButtonPollType {
	return &tgo.KeyboardButtonPollType{
		Type: tgo.PollTypeQuiz,
	}
}

// InlineKeyboard creates tgo.InlineKeyboardMarkup from slice of keyboard buttons
func InlineKeyboard(rows ...[]tgo.InlineKeyboardButton) *tgo.InlineKeyboardMarkup {
	return &tgo.InlineKeyboardMarkup{
		InlineKeyboard: rows,
	}
}

// InlineKeyboardRow creates slice of tgo.InlineKeyboardButton
func InlineKeyboardRow(buttons ...tgo.InlineKeyboardButton) []tgo.InlineKeyboardButton {
	return buttons
}

// InlineKeyboardButton creates tgo.InlineKeyboardButton with required fields
func InlineKeyboardButton(text string) tgo.InlineKeyboardButton {
	return tgo.InlineKeyboardButton{
		Text: text,
	}
}

// ResultCachedAudio creates tgo.InlineQueryResultCachedAudio with required fields
func ResultCachedAudio(id, audioFileID string) *tgo.InlineQueryResultCachedAudio {
	return &tgo.InlineQueryResultCachedAudio{
		Type:        tgo.ResultTypeAudio,
		ID:          id,
		AudioFileID: audioFileID,
	}
}

// ResultCachedDocument creates tgo.InlineQueryResultCachedDocument with required fields
func ResultCachedDocument(id, title, documentFileID string) *tgo.InlineQueryResultCachedDocument {
	return &tgo.InlineQueryResultCachedDocument{
		Type:           tgo.ResultTypeDocument,
		ID:             id,
		Title:          title,
		DocumentFileID: documentFileID,
	}
}

// ResultCachedGif creates tgo.InlineQueryResultCachedGif with required fields
func ResultCachedGif(id, gifFileID string) *tgo.InlineQueryResultCachedGif {
	return &tgo.InlineQueryResultCachedGif{
		Type:      tgo.ResultTypeGif,
		ID:        id,
		GifFileID: gifFileID,
	}
}

// ResultCachedMpeg4Gif creates tgo.InlineQueryResultCachedMpeg4Gif with required fields
func ResultCachedMpeg4Gif(id, mpeg4FileID string) *tgo.InlineQueryResultCachedMpeg4Gif {
	return &tgo.InlineQueryResultCachedMpeg4Gif{
		Type:        tgo.ResultTypeMpeg4Gif,
		ID:          id,
		Mpeg4FileID: mpeg4FileID,
	}
}

// ResultCachedPhoto creates tgo.InlineQueryResultCachedPhoto with required fields
func ResultCachedPhoto(id, photoFileID string) *tgo.InlineQueryResultCachedPhoto {
	return &tgo.InlineQueryResultCachedPhoto{
		Type:        tgo.ResultTypePhoto,
		ID:          id,
		PhotoFileID: photoFileID,
	}
}

// ResultCachedSticker creates tgo.InlineQueryResultCachedSticker with required fields
func ResultCachedSticker(id, stickerFileID string) *tgo.InlineQueryResultCachedSticker {
	return &tgo.InlineQueryResultCachedSticker{
		Type:          tgo.ResultTypeSticker,
		ID:            id,
		StickerFileID: stickerFileID,
	}
}

// ResultCachedVideo creates tgo.InlineQueryResultCachedVideo with required fields
func ResultCachedVideo(id, videoFileID, title string) *tgo.InlineQueryResultCachedVideo {
	return &tgo.InlineQueryResultCachedVideo{
		Type:        tgo.ResultTypeVideo,
		ID:          id,
		VideoFileID: videoFileID,
		Title:       title,
	}
}

// ResultCachedVoice creates tgo.InlineQueryResultCachedVoice with required fields
func ResultCachedVoice(id, voiceFileID, title string) *tgo.InlineQueryResultCachedVoice {
	return &tgo.InlineQueryResultCachedVoice{
		Type:        tgo.ResultTypeVoice,
		ID:          id,
		VoiceFileID: voiceFileID,
		Title:       title,
	}
}

// ResultArticle creates tgo.InlineQueryResultArticle with required fields
func ResultArticle(id, title string, inputMessageContent tgo.InputMessageContent,
) *tgo.InlineQueryResultArticle {
	return &tgo.InlineQueryResultArticle{
		Type:                tgo.ResultTypeArticle,
		ID:                  id,
		Title:               title,
		InputMessageContent: inputMessageContent,
	}
}

// ResultAudio creates tgo.InlineQueryResultAudio with required fields
func ResultAudio(id, audioURL, title string) *tgo.InlineQueryResultAudio {
	return &tgo.InlineQueryResultAudio{
		Type:     tgo.ResultTypeAudio,
		ID:       id,
		AudioURL: audioURL,
		Title:    title,
	}
}

// ResultContact creates tgo.InlineQueryResultContact with required fields
func ResultContact(id, phoneNumber, firstName string) *tgo.InlineQueryResultContact {
	return &tgo.InlineQueryResultContact{
		Type:        tgo.ResultTypeContact,
		ID:          id,
		PhoneNumber: phoneNumber,
		FirstName:   firstName,
	}
}

// ResultGame creates tgo.InlineQueryResultGame with required fields
func ResultGame(id, gameShortName string) *tgo.InlineQueryResultGame {
	return &tgo.InlineQueryResultGame{
		Type:          tgo.ResultTypeGame,
		ID:            id,
		GameShortName: gameShortName,
	}
}

// ResultDocument creates tgo.InlineQueryResultDocument with required fields
func ResultDocument(id, title, documentURL, mimeType string) *tgo.InlineQueryResultDocument {
	return &tgo.InlineQueryResultDocument{
		Type:        tgo.ResultTypeDocument,
		ID:          id,
		Title:       title,
		DocumentURL: documentURL,
		MimeType:    mimeType,
	}
}

// ResultGif creates tgo.InlineQueryResultGif with required fields
func ResultGif(id, gifURL, thumbURL string) *tgo.InlineQueryResultGif {
	return &tgo.InlineQueryResultGif{
		Type:     tgo.ResultTypeGif,
		ID:       id,
		GifURL:   gifURL,
		ThumbURL: thumbURL,
	}
}

// ResultLocation creates tgo.InlineQueryResultLocation with required fields
func ResultLocation(id string, latitude, longitude float64, title string) *tgo.InlineQueryResultLocation {
	return &tgo.InlineQueryResultLocation{
		Type:      tgo.ResultTypeLocation,
		ID:        id,
		Latitude:  latitude,
		Longitude: longitude,
		Title:     title,
	}
}

// ResultMpeg4Gif creates tgo.InlineQueryResultMpeg4Gif with required fields
func ResultMpeg4Gif(id, mpeg4URL, thumbURL string) *tgo.InlineQueryResultMpeg4Gif {
	return &tgo.InlineQueryResultMpeg4Gif{
		Type:     tgo.ResultTypeMpeg4Gif,
		ID:       id,
		Mpeg4URL: mpeg4URL,
		ThumbURL: thumbURL,
	}
}

// ResultPhoto creates tgo.InlineQueryResultPhoto with required fields
func ResultPhoto(id, photoURL, thumbURL string) *tgo.InlineQueryResultPhoto {
	return &tgo.InlineQueryResultPhoto{
		Type:     tgo.ResultTypePhoto,
		ID:       id,
		PhotoURL: photoURL,
		ThumbURL: thumbURL,
	}
}

// ResultVenue creates tgo.InlineQueryResultVenue with required fields
func ResultVenue(id string, latitude, longitude float64, title, address string,
) *tgo.InlineQueryResultVenue {
	return &tgo.InlineQueryResultVenue{
		Type:      tgo.ResultTypeVenue,
		ID:        id,
		Latitude:  latitude,
		Longitude: longitude,
		Title:     title,
		Address:   address,
	}
}

// ResultVideo creates tgo.InlineQueryResultVideo with required fields
func ResultVideo(id, videoURL, mimeType, thumbURL, title string) *tgo.InlineQueryResultVideo {
	return &tgo.InlineQueryResultVideo{
		Type:     tgo.ResultTypeVideo,
		ID:       id,
		VideoURL: videoURL,
		MimeType: mimeType,
		ThumbURL: thumbURL,
		Title:    title,
	}
}

// ResultVoice creates tgo.InlineQueryResultVoice with required fields
func ResultVoice(id, voiceURL, title string) *tgo.InlineQueryResultVoice {
	return &tgo.InlineQueryResultVoice{
		Type:     tgo.ResultTypeVoice,
		ID:       id,
		VoiceURL: voiceURL,
		Title:    title,
	}
}

// TextMessage creates tgo.InputTextMessageContent with required fields
func TextMessage(messageText string) *tgo.InputTextMessageContent {
	return &tgo.InputTextMessageContent{
		MessageText: messageText,
	}
}

// LocationMessage creates tgo.InputLocationMessageContent with required fields
func LocationMessage(latitude, longitude float64) *tgo.InputLocationMessageContent {
	return &tgo.InputLocationMessageContent{
		Latitude:  latitude,
		Longitude: longitude,
	}
}

// VenueMessage creates tgo.InputVenueMessageContent with required fields
func VenueMessage(latitude, longitude float64, title, address string) *tgo.InputVenueMessageContent {
	return &tgo.InputVenueMessageContent{
		Latitude:  latitude,
		Longitude: longitude,
		Title:     title,
		Address:   address,
	}
}

// ContactMessage creates tgo.InputContactMessageContent with required fields
func ContactMessage(phoneNumber, firstName string) *tgo.InputContactMessageContent {
	return &tgo.InputContactMessageContent{
		PhoneNumber: phoneNumber,
		FirstName:   firstName,
	}
}

// InvoiceMessage creates tgo.InputInvoiceMessageContent with required fields
func InvoiceMessage(title, description, payload, providerToken, currency string, prices ...tgo.LabeledPrice,
) *tgo.InputInvoiceMessageContent {
	return &tgo.InputInvoiceMessageContent{
		Title:         title,
		Description:   description,
		Payload:       payload,
		ProviderToken: providerToken,
		Currency:      currency,
		Prices:        prices,
	}
}

// MediaAnimation creates tgo.InputMediaAnimation with required fields
func MediaAnimation(media tgo.InputFile) *tgo.InputMediaAnimation {
	return &tgo.InputMediaAnimation{
		Type:  tgo.MediaTypeAnimation,
		Media: media,
	}
}

// MediaDocument creates tgo.InputMediaDocument with required fields
func MediaDocument(media tgo.InputFile) *tgo.InputMediaDocument {
	return &tgo.InputMediaDocument{
		Type:  tgo.MediaTypeDocument,
		Media: media,
	}
}

// MediaAudio creates tgo.InputMediaAudio with required fields
func MediaAudio(media tgo.InputFile) *tgo.InputMediaAudio {
	return &tgo.InputMediaAudio{
		Type:  tgo.MediaTypeAudio,
		Media: media,
	}
}

// MediaPhoto creates tgo.InputMediaPhoto with required fields
func MediaPhoto(media tgo.InputFile) *tgo.InputMediaPhoto {
	return &tgo.InputMediaPhoto{
		Type:  tgo.MediaTypePhoto,
		Media: media,
	}
}

// MediaVideo creates tgo.InputMediaVideo with required fields
func MediaVideo(media tgo.InputFile) *tgo.InputMediaVideo {
	return &tgo.InputMediaVideo{
		Type:  tgo.MediaTypeVideo,
		Media: media,
	}
}

// ScopeDefault creates tgo.BotCommandScopeDefault with required fields
func ScopeDefault() *tgo.BotCommandScopeDefault {
	return &tgo.BotCommandScopeDefault{
		Type: tgo.ScopeTypeDefault,
	}
}

// ScopeAllPrivateChats creates tgo.BotCommandScopeAllPrivateChats with required fields
func ScopeAllPrivateChats() *tgo.BotCommandScopeAllPrivateChats {
	return &tgo.BotCommandScopeAllPrivateChats{
		Type: tgo.ScopeTypeAllPrivateChats,
	}
}

// ScopeAllGroupChats creates tgo.BotCommandScopeAllGroupChats with required fields
func ScopeAllGroupChats() *tgo.BotCommandScopeAllGroupChats {
	return &tgo.BotCommandScopeAllGroupChats{
		Type: tgo.ScopeTypeAllGroupChats,
	}
}

// ScopeAllChatAdministrators creates tgo.BotCommandScopeAllChatAdministrators with required fields
func ScopeAllChatAdministrators() *tgo.BotCommandScopeAllChatAdministrators {
	return &tgo.BotCommandScopeAllChatAdministrators{
		Type: tgo.ScopeTypeAllChatAdministrators,
	}
}

// ScopeChat creates tgo.BotCommandScopeChat with required fields
func ScopeChat(chatID tgo.ChatID) *tgo.BotCommandScopeChat {
	return &tgo.BotCommandScopeChat{
		Type:   tgo.ScopeTypeChat,
		ChatID: chatID,
	}
}

// ScopeChatAdministrators creates tgo.BotCommandScopeChatAdministrators with required fields
func ScopeChatAdministrators(chatID tgo.ChatID) *tgo.BotCommandScopeChatAdministrators {
	return &tgo.BotCommandScopeChatAdministrators{
		Type:   tgo.ScopeTypeChatAdministrators,
		ChatID: chatID,
	}
}

// ScopeChatMember creates tgo.BotCommandScopeChatMember with required fields
func ScopeChatMember(chatID tgo.ChatID, userID int64) *tgo.BotCommandScopeChatMember {
	return &tgo.BotCommandScopeChatMember{
		Type:   tgo.ScopeTypeChatMember,
		ChatID: chatID,
		UserID: userID,
	}
}

// ErrorDataField creates tgo.PassportElementErrorDataField with required fields
func ErrorDataField(sourceType, message, fieldName, dataHash string) *tgo.PassportElementErrorDataField {
	return &tgo.PassportElementErrorDataField{
		Source:    tgo.ErrorSourceDataField,
		Type:      sourceType,
		FieldName: fieldName,
		DataHash:  dataHash,
		Message:   message,
	}
}

// ErrorFrontSide creates tgo.PassportElementErrorFrontSide with required fields
func ErrorFrontSide(sourceType, message, fileHash string) *tgo.PassportElementErrorFrontSide {
	return &tgo.PassportElementErrorFrontSide{
		Source:   tgo.ErrorSourceFrontSide,
		Type:     sourceType,
		FileHash: fileHash,
		Message:  message,
	}
}

// ErrorReverseSide creates tgo.PassportElementErrorReverseSide with required fields
func ErrorReverseSide(sourceType, message, fileHash string) *tgo.PassportElementErrorReverseSide {
	return &tgo.PassportElementErrorReverseSide{
		Source:   tgo.ErrorSourceReverseSide,
		Type:     sourceType,
		FileHash: fileHash,
		Message:  message,
	}
}

// ErrorSelfie creates tgo.PassportElementErrorSelfie with required fields
func ErrorSelfie(sourceType, message, fileHash string) *tgo.PassportElementErrorSelfie {
	return &tgo.PassportElementErrorSelfie{
		Source:   tgo.ErrorSourceSelfie,
		Type:     sourceType,
		FileHash: fileHash,
		Message:  message,
	}
}

// ErrorFile creates tgo.PassportElementErrorFile with required fields
func ErrorFile(sourceType, message, fileHash string) *tgo.PassportElementErrorFile {
	return &tgo.PassportElementErrorFile{
		Source:   tgo.ErrorSourceFile,
		Type:     sourceType,
		FileHash: fileHash,
		Message:  message,
	}
}

// ErrorFiles creates tgo.PassportElementErrorFiles with required fields
func ErrorFiles(sourceType, message string, fileHashes ...string) *tgo.PassportElementErrorFiles {
	return &tgo.PassportElementErrorFiles{
		Source:     tgo.ErrorSourceFiles,
		Type:       sourceType,
		FileHashes: fileHashes,
		Message:    message,
	}
}

// ErrorTranslationFile creates tgo.PassportElementErrorTranslationFile with required fields
func ErrorTranslationFile(sourceType, message, fileHash string) *tgo.PassportElementErrorTranslationFile {
	return &tgo.PassportElementErrorTranslationFile{
		Source:   tgo.ErrorSourceTranslationFile,
		Type:     sourceType,
		FileHash: fileHash,
		Message:  message,
	}
}

// ErrorTranslationFiles creates tgo.PassportElementErrorTranslationFiles with required fields
func ErrorTranslationFiles(sourceType, message string, fileHashes ...string,
) *tgo.PassportElementErrorTranslationFiles {
	return &tgo.PassportElementErrorTranslationFiles{
		Source:     tgo.ErrorSourceTranslationFiles,
		Type:       sourceType,
		FileHashes: fileHashes,
		Message:    message,
	}
}

// ErrorUnspecified creates tgo.PassportElementErrorUnspecified with required fields
func ErrorUnspecified(sourceType, message, elementHash string) *tgo.PassportElementErrorUnspecified {
	return &tgo.PassportElementErrorUnspecified{
		Source:      tgo.ErrorSourceUnspecified,
		Type:        sourceType,
		ElementHash: elementHash,
		Message:     message,
	}
}

// LabeledPrice creates tgo.LabeledPrice with required parameters
func LabeledPrice(label string, amount int) tgo.LabeledPrice {
	return tgo.LabeledPrice{
		Label:  label,
		Amount: amount,
	}
}

// ShippingOption creates tgo.ShippingOption with required parameters
func ShippingOption(id, title string, prices ...tgo.LabeledPrice) tgo.ShippingOption {
	return tgo.ShippingOption{
		ID:     id,
		Title:  title,
		Prices: prices,
	}
}