tdlib

type AuthCodeType int

type AuthorizationState struct {
	// Kind identifies the phase.
	Kind AuthorizationStateKind
	// WaitCode is set when Kind == AuthorizationStateWaitCode.
	WaitCode *AuthorizationStateWaitCodeInfo
	// WaitPassword is set when Kind == AuthorizationStateWaitPassword.
	WaitPassword *AuthorizationStateWaitPasswordInfo
	// WaitRegistration is set when Kind == AuthorizationStateWaitRegistration.
	WaitRegistration *AuthorizationStateWaitRegistrationInfo
	// OtherDevice is set when Kind == AuthorizationStateWaitOtherDeviceConfirmation.
	OtherDevice *AuthorizationStateWaitOtherDeviceInfo
}

type AuthorizationStateKind int

type AuthorizationStateWaitCodeInfo struct {
	// PhoneNumber is the number the code was sent to.
	PhoneNumber string
	// Type describes how the code was delivered.
	Type AuthCodeType
	// Timeout is the number of seconds the code remains valid.
	Timeout int
}

type AuthorizationStateWaitOtherDeviceInfo struct {
	// Link is the tg://login?token=… URL to render as a QR code for the user to
	// scan with an already-authorized device.
	Link string
}

type AuthorizationStateWaitPasswordInfo struct {
	// PasswordHint is the user-set hint; may be empty.
	PasswordHint string
	// HasRecoveryEmailAddress reports whether a recovery email is configured.
	HasRecoveryEmailAddress bool
	// RecoveryEmailAddressPattern is the masked recovery email, e.g.
	// "ab***@example.com"; empty when no recovery email is set.
	RecoveryEmailAddressPattern string
}

type AuthorizationStateWaitRegistrationInfo struct {
	// TermsOfService is the human-readable Terms of Service text to present to
	// the user.
	TermsOfService string
}

type Chat struct {
	// ID is the Telegram chat identifier (treated as an opaque int64).
	ID ChatID
	// Type is the peer kind.
	Type ChatType
	// Title is the display name; for private chats it is the peer's full name.
	Title string
	// UserID is the peer user when Type == ChatTypePrivate; zero otherwise.
	UserID UserID
	// AccessHash is required to address Channel-backed chats; zero otherwise.
	AccessHash int64
	// LastMessageID is the id of the most recent message; zero if none.
	LastMessageID MessageID
	// LastMessageDate is the Unix timestamp of the most recent message; the
	// primary dialog-list sort key.
	LastMessageDate int64
	// Pinned reports whether the chat is pinned at the top of the main list.
	Pinned bool
	// UnreadCount is the number of unread incoming messages.
	UnreadCount int
	// LastReadInboxMessageID is the max incoming message id the user has read.
	LastReadInboxMessageID MessageID
	// LastReadOutboxMessageID is the max outgoing message id acknowledged read.
	LastReadOutboxMessageID MessageID
	// DraftText is the locally-saved draft text, or empty.
	DraftText string
}

type ChatDraftUpdate struct {
	ChatID    ChatID
	DraftText string
}

type ChatID int64

type ChatLastMessageUpdate struct {
	ChatID          ChatID
	LastMessageID   MessageID
	LastMessageDate int64
}

type ChatList struct {
	// Chats is the ordered slice of chat headers (pinned first, then by
	// LastMessageDate descending).
	Chats []*Chat
	// TotalCount is the server-reported total dialog count; may exceed
	// len(Chats) when paging is incomplete.
	TotalCount int
}

type ChatReadInboxUpdate struct {
	ChatID                 ChatID
	LastReadInboxMessageID MessageID
	UnreadCount            int
}

type ChatReadOutboxUpdate struct {
	ChatID                  ChatID
	LastReadOutboxMessageID MessageID
}

type ChatType int

type Client struct {
	// contains filtered or unexported fields
}

type ConnectionState int

type ConnectionStateUpdate struct {
	State ConnectionState
}

type DeletedMessages struct {
	ChatID     ChatID
	MessageIDs []MessageID
}

type Error struct {
	// Code is the Telegram API error code.
	Code int
	// Message is the human-readable error description.
	Message string
}

type File struct {
	// ID is the stable local file identifier assigned by tdlib.
	ID FileID
	// Size is the known file size in bytes; 0 when unknown.
	Size int64
	// Local holds the local copy state.
	Local LocalFile
	// Remote holds the remote location state.
	Remote RemoteFile
}

type FileID int32

type ImportContactsRequest struct {
	// ClientID is a caller-assigned integer used to correlate results.
	ClientID int64
	// Phone is the phone number to import in international format.
	Phone string
	// FirstName is the contact's first name.
	FirstName string
	// LastName is the contact's last name; may be empty.
	LastName string
}

type ImportedContact struct {
	// ClientID echoes the request's ClientID.
	ClientID int64
	// User is the matched account, or nil when no match was found.
	User *User
}

type InputMessageContent struct {
	// Kind selects the active payload field.
	Kind InputMessageContentKind
	// Text is set when Kind == InputMessageContentKindText.
	Text *InputMessageText
	// Document is set when Kind == InputMessageContentKindDocument.
	Document *InputMessageDocument
}

type InputMessageContentKind int

type InputMessageDocument struct {
	// FileID is the local file id from Client.StageUpload.
	FileID FileID
	// Caption is the optional text caption.
	Caption string
}

type InputMessageText struct {
	// Text is the message body.
	Text string
	// Entities is optional rich-text formatting; nil means none.
	Entities []MessageEntity
	// DisableWebPagePreview suppresses the link-preview box.
	DisableWebPagePreview bool
}

type LocalFile struct {
	// Path is the absolute path to the local file; empty when not downloaded.
	Path string
	// CanBeDownloaded is true if the file can still be downloaded from Telegram.
	CanBeDownloaded bool
	// IsDownloadingActive is true while a DownloadFile call is in progress.
	IsDownloadingActive bool
	// IsDownloadingCompleted is true when the full file is available locally.
	IsDownloadingCompleted bool
	// DownloadedSize is the number of bytes written so far.
	DownloadedSize int64
}

type Message struct {
	// ID is the message identifier, unique within the owning chat.
	ID MessageID
	// ChatID is the chat that contains this message.
	ChatID ChatID
	// SenderID is the user who sent it; zero for anonymous channel posts.
	SenderID UserID
	// Date is the UTC timestamp when the message was sent.
	Date time.Time
	// EditDate is the UTC timestamp of the most recent edit, or zero.
	EditDate time.Time
	// IsOutgoing reports whether the message was sent by the authenticated user.
	IsOutgoing bool
	// ReplyTo identifies the replied-to message, or nil.
	ReplyTo *MessageReplyTo
	// Content holds the typed message body.
	Content MessageContent
	// SendingState is non-nil for outgoing messages awaiting server
	// confirmation (RFC 0011); nil for incoming or delivered messages.
	SendingState *MessageSendingState
}

type MessageContent struct {
	// Kind identifies which payload field is set.
	Kind MessageContentKind
	// Text is set when Kind == MessageContentKindText.
	Text *MessageText
}

type MessageContentKind int

type MessageEntity struct {
	// Type is the entity kind (bold, italic, code, mention, …).
	Type string
	// Offset is the UTF-16 code-unit start of the span.
	Offset int
	// Length is the UTF-16 code-unit length of the span.
	Length int
}

type MessageID int64

type MessageReplyTo struct {
	// ChatID is the chat containing the original message; zero when the reply
	// is in the same chat.
	ChatID ChatID
	// MessageID is the id of the message being replied to.
	MessageID MessageID
}

type MessageSendFailed struct {
	// Message is the message as stored locally (still using the temp id).
	Message *Message
	// OldMessageID is the temporary local id.
	OldMessageID MessageID
	// Error is the RPC error that caused the failure.
	Error *Error
}

type MessageSendSucceeded struct {
	// Message is the final message with its real server-assigned id.
	Message *Message
	// OldMessageID is the temporary local id it replaced.
	OldMessageID MessageID
}

type MessageSendingState struct {
	// Kind identifies whether the message is pending or failed.
	Kind MessageSendingStateKind
	// Error is set when Kind == MessageSendingStateFailed.
	Error *Error
}

type MessageSendingStateKind int

type MessageText struct {
	// Text is the message body as a plain string.
	Text string
	// Entities is reserved for rich-text formatting; nil in v1.
	Entities []MessageEntity
}

type Messages struct {
	// Items is the ordered page, newest first (descending by id).
	Items []*Message
	// TotalCount is the server-reported total; zero when served from cache.
	TotalCount int
}

type Option func(*options)

type OptionValue struct {
	// Kind identifies which payload field is active.
	Kind OptionValueKind
	// Boolean is set when Kind == OptionValueKindBoolean.
	Boolean bool
	// Integer is set when Kind == OptionValueKindInteger.
	Integer int64
	// String is set when Kind == OptionValueKindString.
	String string
}

type OptionValueKind int

type PendingSendEntry struct {
	// BinlogID is the binlog row id; used to confirm the entry on success.
	BinlogID int64 `json:"-"`
	// ChatID identifies the chat.
	ChatID ChatID `json:"chat_id"`
	// TempMessageID is the temporary local id of the pending message.
	TempMessageID MessageID `json:"temp_id"`
	// RandomID is the random_id used for server-side deduplication.
	RandomID int64 `json:"random_id"`
	// Text is the message body to re-send.
	Text string `json:"text"`
	// ReplyToMessageID is non-zero when the message is a reply.
	ReplyToMessageID MessageID `json:"reply_to,omitempty"`
}

type RemoteFile struct {
	// ID is the opaque remote file identifier usable across restarts.
	ID string
	// UniqueID is the stable content identifier shared across users.
	UniqueID string
	// IsUploadingActive is true while an UploadFile call is in progress.
	IsUploadingActive bool
	// IsUploadingCompleted is true after a successful upload.
	IsUploadingCompleted bool
	// UploadedSize is the number of bytes confirmed uploaded so far.
	UploadedSize int64
}

type SendMessageOptions struct {
	// ReplyToMessageHolder is the message id to reply to; zero means no reply.
	ReplyToMessageID MessageID
}

type Sink interface {
	// Push enqueues one update for delivery to the caller. It returns an error
	// only when the Client has been closed or ctx is cancelled.
	Push(ctx context.Context, u Update) error
}

type Transport interface {
	// Run starts the underlying MTProto session and blocks until ctx is
	// cancelled or a fatal error occurs.
	Run(ctx context.Context) error
	// API returns the raw TL client for issuing MTProto RPCs. Safe for
	// concurrent use.
	API() *tg.Client
	// Self blocks until authentication completes and returns the authorized
	// user.
	Self(ctx context.Context) (*tg.User, error)
	// Close gracefully shuts down the transport.
	Close() error
}

type Update struct {
	// Kind identifies which payload field is set.
	Kind UpdateKind

	// AuthorizationState is set when Kind == UpdateKindAuthorizationState.
	AuthorizationState *AuthorizationState
	// NewMessage is set when Kind == UpdateKindNewMessage.
	NewMessage *Message
	// DeletedMessages is set when Kind == UpdateKindDeleteMessages.
	DeletedMessages *DeletedMessages
	// User is set when Kind == UpdateKindUser.
	User *User
	// Chat is set when Kind == UpdateKindChat.
	Chat *Chat
	// ConnectionState is set when Kind == UpdateKindConnectionState.
	ConnectionState *ConnectionStateUpdate
	// File is set when Kind == UpdateKindFile.
	File *File
	// Option is set when Kind == UpdateKindOption.
	Option *UpdateOption
	// ChatReadInbox is set when Kind == UpdateKindChatReadInbox.
	ChatReadInbox *ChatReadInboxUpdate
	// ChatReadOutbox is set when Kind == UpdateKindChatReadOutbox.
	ChatReadOutbox *ChatReadOutboxUpdate
	// ChatLastMessage is set when Kind == UpdateKindChatLastMessage.
	ChatLastMessage *ChatLastMessageUpdate
	// ChatDraftMessage is set when Kind == UpdateKindChatDraftMessage.
	ChatDraftMessage *ChatDraftUpdate
	// SendSucceeded is set when Kind == UpdateKindMessageSendSucceeded.
	SendSucceeded *MessageSendSucceeded
	// SendFailed is set when Kind == UpdateKindMessageSendFailed.
	SendFailed *MessageSendFailed
	// EditedMessage is set when Kind == UpdateKindMessageEdited.
	EditedMessage *Message
}

type UpdateKind int

type UpdateOption struct {
	// Name is the option name, e.g. "my_id", "version".
	Name string
	// Value is the new value.
	Value OptionValue
}

type User struct {
	// ID is the Telegram user identifier.
	ID UserID
	// AccessHash is the opaque token required to address this user in MTProto
	// RPCs via tg.InputUser. It is persisted and never overwritten with zero
	// once known.
	AccessHash int64
	// FirstName is the user's first name.
	FirstName string
	// LastName is the user's last name; may be empty.
	LastName string
	// Username is the primary username without the leading "@"; may be empty.
	Username string
	// Usernames holds all active usernames; the primary one is first.
	Usernames []string
	// Phone is the international-format phone number; set only when accessible.
	Phone string
	// Status is the last known online presence.
	Status UserStatus
	// IsBot is true when the account belongs to a bot.
	IsBot bool
	// IsContact is true when this user is in the account's contact list.
	IsContact bool
	// IsMutualContact is true when the contact relationship is mutual.
	IsMutualContact bool
	// IsSelf is true when this user is the authenticated account itself.
	IsSelf bool
	// IsMin is true when the object was received as a "min" user (incomplete,
	// without a usable access_hash).
	IsMin bool
}

type UserID int64

type UserStatus struct {
	// Kind is the presence variant.
	Kind UserStatusKind
	// Expires is the online-window close time when Kind == UserStatusKindOnline.
	Expires time.Time
	// WasOnline is the last-seen time when Kind == UserStatusKindOffline.
	WasOnline time.Time
}

type UserStatusKind int