Source File
	tl_input_rich_message_gen.go

Belonging Package
	github.com/gotd/td/tg

// Code generated by gotdgen, DO NOT EDIT.

package tg

import (
	"context"
	"errors"
	"fmt"
	"sort"
	"strings"

	"go.uber.org/multierr"

	"github.com/gotd/td/bin"
	"github.com/gotd/td/tdjson"
	"github.com/gotd/td/tdp"
	"github.com/gotd/td/tgerr"
)

// No-op definition for keeping imports.
var (
	_ = bin.Buffer{}
	_ = context.Background()
	_ = fmt.Stringer(nil)
	_ = strings.Builder{}
	_ = errors.Is
	_ = multierr.AppendInto
	_ = sort.Ints
	_ = tdp.Format
	_ = tgerr.Error{}
	_ = tdjson.Encoder{}
)

// InputRichMessage represents TL type `inputRichMessage#e4c449fc`.
//
// See https://core.telegram.org/constructor/inputRichMessage for reference.
type InputRichMessage struct {
	// Flags field of InputRichMessage.
	Flags bin.Fields
	// Rtl field of InputRichMessage.
	Rtl bool
	// Noautolink field of InputRichMessage.
	Noautolink bool
	// Blocks field of InputRichMessage.
	Blocks []PageBlockClass
	// Photos field of InputRichMessage.
	//
	// Use SetPhotos and GetPhotos helpers.
	Photos []InputPhotoClass
	// Documents field of InputRichMessage.
	//
	// Use SetDocuments and GetDocuments helpers.
	Documents []InputDocumentClass
	// Users field of InputRichMessage.
	//
	// Use SetUsers and GetUsers helpers.
	Users []InputUserClass
}

// InputRichMessageTypeID is TL type id of InputRichMessage.
const InputRichMessageTypeID = 0xe4c449fc

// construct implements constructor of InputRichMessageClass.
func (i InputRichMessage) construct() InputRichMessageClass { return &i }

// Ensuring interfaces in compile-time for InputRichMessage.
var (
	_ bin.Encoder     = &InputRichMessage{}
	_ bin.Decoder     = &InputRichMessage{}
	_ bin.BareEncoder = &InputRichMessage{}
	_ bin.BareDecoder = &InputRichMessage{}

	_ InputRichMessageClass = &InputRichMessage{}
)

func (i *InputRichMessage) Zero() bool {
	if i == nil {
		return true
	}
	if !(i.Flags.Zero()) {
		return false
	}
	if !(i.Rtl == false) {
		return false
	}
	if !(i.Noautolink == false) {
		return false
	}
	if !(i.Blocks == nil) {
		return false
	}
	if !(i.Photos == nil) {
		return false
	}
	if !(i.Documents == nil) {
		return false
	}
	if !(i.Users == nil) {
		return false
	}

	return true
}

// String implements fmt.Stringer.
func (i *InputRichMessage) String() string {
	if i == nil {
		return "InputRichMessage(nil)"
	}
	type Alias InputRichMessage
	return fmt.Sprintf("InputRichMessage%+v", Alias(*i))
}

// FillFrom fills InputRichMessage from given interface.
func (i *InputRichMessage) FillFrom(from interface {
	GetRtl() (value bool)
	GetNoautolink() (value bool)
	GetBlocks() (value []PageBlockClass)
	GetPhotos() (value []InputPhotoClass, ok bool)
	GetDocuments() (value []InputDocumentClass, ok bool)
	GetUsers() (value []InputUserClass, ok bool)
}) {
	i.Rtl = from.GetRtl()
	i.Noautolink = from.GetNoautolink()
	i.Blocks = from.GetBlocks()
	if val, ok := from.GetPhotos(); ok {
		i.Photos = val
	}

	if val, ok := from.GetDocuments(); ok {
		i.Documents = val
	}

	if val, ok := from.GetUsers(); ok {
		i.Users = val
	}

}

// TypeID returns type id in TL schema.
//
// See https://core.telegram.org/mtproto/TL-tl#remarks.
func (*InputRichMessage) TypeID() uint32 {
	return InputRichMessageTypeID
}

// TypeName returns name of type in TL schema.
func (*InputRichMessage) TypeName() string {
	return "inputRichMessage"
}

// TypeInfo returns info about TL type.
func (i *InputRichMessage) TypeInfo() tdp.Type {
	typ := tdp.Type{
		Name: "inputRichMessage",
		ID:   InputRichMessageTypeID,
	}
	if i == nil {
		typ.Null = true
		return typ
	}
	typ.Fields = []tdp.Field{
		{
			Name:       "Rtl",
			SchemaName: "rtl",
			Null:       !i.Flags.Has(0),
		},
		{
			Name:       "Noautolink",
			SchemaName: "noautolink",
			Null:       !i.Flags.Has(1),
		},
		{
			Name:       "Blocks",
			SchemaName: "blocks",
		},
		{
			Name:       "Photos",
			SchemaName: "photos",
			Null:       !i.Flags.Has(2),
		},
		{
			Name:       "Documents",
			SchemaName: "documents",
			Null:       !i.Flags.Has(3),
		},
		{
			Name:       "Users",
			SchemaName: "users",
			Null:       !i.Flags.Has(4),
		},
	}
	return typ
}

// SetFlags sets flags for non-zero fields.
func (i *InputRichMessage) SetFlags() {
	if !(i.Rtl == false) {
		i.Flags.Set(0)
	}
	if !(i.Noautolink == false) {
		i.Flags.Set(1)
	}
	if !(i.Photos == nil) {
		i.Flags.Set(2)
	}
	if !(i.Documents == nil) {
		i.Flags.Set(3)
	}
	if !(i.Users == nil) {
		i.Flags.Set(4)
	}
}

// Encode implements bin.Encoder.
func (i *InputRichMessage) Encode(b *bin.Buffer) error {
	if i == nil {
		return fmt.Errorf("can't encode inputRichMessage#e4c449fc as nil")
	}
	b.PutID(InputRichMessageTypeID)
	return i.EncodeBare(b)
}

// EncodeBare implements bin.BareEncoder.
func (i *InputRichMessage) EncodeBare(b *bin.Buffer) error {
	if i == nil {
		return fmt.Errorf("can't encode inputRichMessage#e4c449fc as nil")
	}
	i.SetFlags()
	if err := i.Flags.Encode(b); err != nil {
		return fmt.Errorf("unable to encode inputRichMessage#e4c449fc: field flags: %w", err)
	}
	b.PutVectorHeader(len(i.Blocks))
	for idx, v := range i.Blocks {
		if v == nil {
			return fmt.Errorf("unable to encode inputRichMessage#e4c449fc: field blocks element with index %d is nil", idx)
		}
		if err := v.Encode(b); err != nil {
			return fmt.Errorf("unable to encode inputRichMessage#e4c449fc: field blocks element with index %d: %w", idx, err)
		}
	}
	if i.Flags.Has(2) {
		b.PutVectorHeader(len(i.Photos))
		for idx, v := range i.Photos {
			if v == nil {
				return fmt.Errorf("unable to encode inputRichMessage#e4c449fc: field photos element with index %d is nil", idx)
			}
			if err := v.Encode(b); err != nil {
				return fmt.Errorf("unable to encode inputRichMessage#e4c449fc: field photos element with index %d: %w", idx, err)
			}
		}
	}
	if i.Flags.Has(3) {
		b.PutVectorHeader(len(i.Documents))
		for idx, v := range i.Documents {
			if v == nil {
				return fmt.Errorf("unable to encode inputRichMessage#e4c449fc: field documents element with index %d is nil", idx)
			}
			if err := v.Encode(b); err != nil {
				return fmt.Errorf("unable to encode inputRichMessage#e4c449fc: field documents element with index %d: %w", idx, err)
			}
		}
	}
	if i.Flags.Has(4) {
		b.PutVectorHeader(len(i.Users))
		for idx, v := range i.Users {
			if v == nil {
				return fmt.Errorf("unable to encode inputRichMessage#e4c449fc: field users element with index %d is nil", idx)
			}
			if err := v.Encode(b); err != nil {
				return fmt.Errorf("unable to encode inputRichMessage#e4c449fc: field users element with index %d: %w", idx, err)
			}
		}
	}
	return nil
}

// Decode implements bin.Decoder.
func (i *InputRichMessage) Decode(b *bin.Buffer) error {
	if i == nil {
		return fmt.Errorf("can't decode inputRichMessage#e4c449fc to nil")
	}
	if err := b.ConsumeID(InputRichMessageTypeID); err != nil {
		return fmt.Errorf("unable to decode inputRichMessage#e4c449fc: %w", err)
	}
	return i.DecodeBare(b)
}

// DecodeBare implements bin.BareDecoder.
func (i *InputRichMessage) DecodeBare(b *bin.Buffer) error {
	if i == nil {
		return fmt.Errorf("can't decode inputRichMessage#e4c449fc to nil")
	}
	{
		if err := i.Flags.Decode(b); err != nil {
			return fmt.Errorf("unable to decode inputRichMessage#e4c449fc: field flags: %w", err)
		}
	}
	i.Rtl = i.Flags.Has(0)
	i.Noautolink = i.Flags.Has(1)
	{
		headerLen, err := b.VectorHeader()
		if err != nil {
			return fmt.Errorf("unable to decode inputRichMessage#e4c449fc: field blocks: %w", err)
		}

		if headerLen > 0 {
			i.Blocks = make([]PageBlockClass, 0, headerLen%bin.PreallocateLimit)
		}
		for idx := 0; idx < headerLen; idx++ {
			value, err := DecodePageBlock(b)
			if err != nil {
				return fmt.Errorf("unable to decode inputRichMessage#e4c449fc: field blocks: %w", err)
			}
			i.Blocks = append(i.Blocks, value)
		}
	}
	if i.Flags.Has(2) {
		headerLen, err := b.VectorHeader()
		if err != nil {
			return fmt.Errorf("unable to decode inputRichMessage#e4c449fc: field photos: %w", err)
		}

		if headerLen > 0 {
			i.Photos = make([]InputPhotoClass, 0, headerLen%bin.PreallocateLimit)
		}
		for idx := 0; idx < headerLen; idx++ {
			value, err := DecodeInputPhoto(b)
			if err != nil {
				return fmt.Errorf("unable to decode inputRichMessage#e4c449fc: field photos: %w", err)
			}
			i.Photos = append(i.Photos, value)
		}
	}
	if i.Flags.Has(3) {
		headerLen, err := b.VectorHeader()
		if err != nil {
			return fmt.Errorf("unable to decode inputRichMessage#e4c449fc: field documents: %w", err)
		}

		if headerLen > 0 {
			i.Documents = make([]InputDocumentClass, 0, headerLen%bin.PreallocateLimit)
		}
		for idx := 0; idx < headerLen; idx++ {
			value, err := DecodeInputDocument(b)
			if err != nil {
				return fmt.Errorf("unable to decode inputRichMessage#e4c449fc: field documents: %w", err)
			}
			i.Documents = append(i.Documents, value)
		}
	}
	if i.Flags.Has(4) {
		headerLen, err := b.VectorHeader()
		if err != nil {
			return fmt.Errorf("unable to decode inputRichMessage#e4c449fc: field users: %w", err)
		}

		if headerLen > 0 {
			i.Users = make([]InputUserClass, 0, headerLen%bin.PreallocateLimit)
		}
		for idx := 0; idx < headerLen; idx++ {
			value, err := DecodeInputUser(b)
			if err != nil {
				return fmt.Errorf("unable to decode inputRichMessage#e4c449fc: field users: %w", err)
			}
			i.Users = append(i.Users, value)
		}
	}
	return nil
}

// SetRtl sets value of Rtl conditional field.
func (i *InputRichMessage) SetRtl(value bool) {
	if value {
		i.Flags.Set(0)
		i.Rtl = true
	} else {
		i.Flags.Unset(0)
		i.Rtl = false
	}
}

// GetRtl returns value of Rtl conditional field.
func (i *InputRichMessage) GetRtl() (value bool) {
	if i == nil {
		return
	}
	return i.Flags.Has(0)
}

// SetNoautolink sets value of Noautolink conditional field.
func (i *InputRichMessage) SetNoautolink(value bool) {
	if value {
		i.Flags.Set(1)
		i.Noautolink = true
	} else {
		i.Flags.Unset(1)
		i.Noautolink = false
	}
}

// GetNoautolink returns value of Noautolink conditional field.
func (i *InputRichMessage) GetNoautolink() (value bool) {
	if i == nil {
		return
	}
	return i.Flags.Has(1)
}

// GetBlocks returns value of Blocks field.
func (i *InputRichMessage) GetBlocks() (value []PageBlockClass) {
	if i == nil {
		return
	}
	return i.Blocks
}

// SetPhotos sets value of Photos conditional field.
func (i *InputRichMessage) SetPhotos(value []InputPhotoClass) {
	i.Flags.Set(2)
	i.Photos = value
}

// GetPhotos returns value of Photos conditional field and
// boolean which is true if field was set.
func (i *InputRichMessage) GetPhotos() (value []InputPhotoClass, ok bool) {
	if i == nil {
		return
	}
	if !i.Flags.Has(2) {
		return value, false
	}
	return i.Photos, true
}

// SetDocuments sets value of Documents conditional field.
func (i *InputRichMessage) SetDocuments(value []InputDocumentClass) {
	i.Flags.Set(3)
	i.Documents = value
}

// GetDocuments returns value of Documents conditional field and
// boolean which is true if field was set.
func (i *InputRichMessage) GetDocuments() (value []InputDocumentClass, ok bool) {
	if i == nil {
		return
	}
	if !i.Flags.Has(3) {
		return value, false
	}
	return i.Documents, true
}

// SetUsers sets value of Users conditional field.
func (i *InputRichMessage) SetUsers(value []InputUserClass) {
	i.Flags.Set(4)
	i.Users = value
}

// GetUsers returns value of Users conditional field and
// boolean which is true if field was set.
func (i *InputRichMessage) GetUsers() (value []InputUserClass, ok bool) {
	if i == nil {
		return
	}
	if !i.Flags.Has(4) {
		return value, false
	}
	return i.Users, true
}

// MapBlocks returns field Blocks wrapped in PageBlockClassArray helper.
func (i *InputRichMessage) MapBlocks() (value PageBlockClassArray) {
	return PageBlockClassArray(i.Blocks)
}

// MapPhotos returns field Photos wrapped in InputPhotoClassArray helper.
func (i *InputRichMessage) MapPhotos() (value InputPhotoClassArray, ok bool) {
	if !i.Flags.Has(2) {
		return value, false
	}
	return InputPhotoClassArray(i.Photos), true
}

// MapDocuments returns field Documents wrapped in InputDocumentClassArray helper.
func (i *InputRichMessage) MapDocuments() (value InputDocumentClassArray, ok bool) {
	if !i.Flags.Has(3) {
		return value, false
	}
	return InputDocumentClassArray(i.Documents), true
}

// MapUsers returns field Users wrapped in InputUserClassArray helper.
func (i *InputRichMessage) MapUsers() (value InputUserClassArray, ok bool) {
	if !i.Flags.Has(4) {
		return value, false
	}
	return InputUserClassArray(i.Users), true
}

// InputRichMessageHTML represents TL type `inputRichMessageHTML#dacb836a`.
//
// See https://core.telegram.org/constructor/inputRichMessageHTML for reference.
type InputRichMessageHTML struct {
	// Flags field of InputRichMessageHTML.
	Flags bin.Fields
	// Rtl field of InputRichMessageHTML.
	Rtl bool
	// Noautolink field of InputRichMessageHTML.
	Noautolink bool
	// HTML field of InputRichMessageHTML.
	HTML string
	// Files field of InputRichMessageHTML.
	//
	// Use SetFiles and GetFiles helpers.
	Files []InputRichFileClass
}

// InputRichMessageHTMLTypeID is TL type id of InputRichMessageHTML.
const InputRichMessageHTMLTypeID = 0xdacb836a

// construct implements constructor of InputRichMessageClass.
func (i InputRichMessageHTML) construct() InputRichMessageClass { return &i }

// Ensuring interfaces in compile-time for InputRichMessageHTML.
var (
	_ bin.Encoder     = &InputRichMessageHTML{}
	_ bin.Decoder     = &InputRichMessageHTML{}
	_ bin.BareEncoder = &InputRichMessageHTML{}
	_ bin.BareDecoder = &InputRichMessageHTML{}

	_ InputRichMessageClass = &InputRichMessageHTML{}
)

func (i *InputRichMessageHTML) Zero() bool {
	if i == nil {
		return true
	}
	if !(i.Flags.Zero()) {
		return false
	}
	if !(i.Rtl == false) {
		return false
	}
	if !(i.Noautolink == false) {
		return false
	}
	if !(i.HTML == "") {
		return false
	}
	if !(i.Files == nil) {
		return false
	}

	return true
}

// String implements fmt.Stringer.
func (i *InputRichMessageHTML) String() string {
	if i == nil {
		return "InputRichMessageHTML(nil)"
	}
	type Alias InputRichMessageHTML
	return fmt.Sprintf("InputRichMessageHTML%+v", Alias(*i))
}

// FillFrom fills InputRichMessageHTML from given interface.
func (i *InputRichMessageHTML) FillFrom(from interface {
	GetRtl() (value bool)
	GetNoautolink() (value bool)
	GetHTML() (value string)
	GetFiles() (value []InputRichFileClass, ok bool)
}) {
	i.Rtl = from.GetRtl()
	i.Noautolink = from.GetNoautolink()
	i.HTML = from.GetHTML()
	if val, ok := from.GetFiles(); ok {
		i.Files = val
	}

}

// TypeID returns type id in TL schema.
//
// See https://core.telegram.org/mtproto/TL-tl#remarks.
func (*InputRichMessageHTML) TypeID() uint32 {
	return InputRichMessageHTMLTypeID
}

// TypeName returns name of type in TL schema.
func (*InputRichMessageHTML) TypeName() string {
	return "inputRichMessageHTML"
}

// TypeInfo returns info about TL type.
func (i *InputRichMessageHTML) TypeInfo() tdp.Type {
	typ := tdp.Type{
		Name: "inputRichMessageHTML",
		ID:   InputRichMessageHTMLTypeID,
	}
	if i == nil {
		typ.Null = true
		return typ
	}
	typ.Fields = []tdp.Field{
		{
			Name:       "Rtl",
			SchemaName: "rtl",
			Null:       !i.Flags.Has(0),
		},
		{
			Name:       "Noautolink",
			SchemaName: "noautolink",
			Null:       !i.Flags.Has(1),
		},
		{
			Name:       "HTML",
			SchemaName: "html",
		},
		{
			Name:       "Files",
			SchemaName: "files",
			Null:       !i.Flags.Has(2),
		},
	}
	return typ
}

// SetFlags sets flags for non-zero fields.
func (i *InputRichMessageHTML) SetFlags() {
	if !(i.Rtl == false) {
		i.Flags.Set(0)
	}
	if !(i.Noautolink == false) {
		i.Flags.Set(1)
	}
	if !(i.Files == nil) {
		i.Flags.Set(2)
	}
}

// Encode implements bin.Encoder.
func (i *InputRichMessageHTML) Encode(b *bin.Buffer) error {
	if i == nil {
		return fmt.Errorf("can't encode inputRichMessageHTML#dacb836a as nil")
	}
	b.PutID(InputRichMessageHTMLTypeID)
	return i.EncodeBare(b)
}

// EncodeBare implements bin.BareEncoder.
func (i *InputRichMessageHTML) EncodeBare(b *bin.Buffer) error {
	if i == nil {
		return fmt.Errorf("can't encode inputRichMessageHTML#dacb836a as nil")
	}
	i.SetFlags()
	if err := i.Flags.Encode(b); err != nil {
		return fmt.Errorf("unable to encode inputRichMessageHTML#dacb836a: field flags: %w", err)
	}
	b.PutString(i.HTML)
	if i.Flags.Has(2) {
		b.PutVectorHeader(len(i.Files))
		for idx, v := range i.Files {
			if v == nil {
				return fmt.Errorf("unable to encode inputRichMessageHTML#dacb836a: field files element with index %d is nil", idx)
			}
			if err := v.Encode(b); err != nil {
				return fmt.Errorf("unable to encode inputRichMessageHTML#dacb836a: field files element with index %d: %w", idx, err)
			}
		}
	}
	return nil
}

// Decode implements bin.Decoder.
func (i *InputRichMessageHTML) Decode(b *bin.Buffer) error {
	if i == nil {
		return fmt.Errorf("can't decode inputRichMessageHTML#dacb836a to nil")
	}
	if err := b.ConsumeID(InputRichMessageHTMLTypeID); err != nil {
		return fmt.Errorf("unable to decode inputRichMessageHTML#dacb836a: %w", err)
	}
	return i.DecodeBare(b)
}

// DecodeBare implements bin.BareDecoder.
func (i *InputRichMessageHTML) DecodeBare(b *bin.Buffer) error {
	if i == nil {
		return fmt.Errorf("can't decode inputRichMessageHTML#dacb836a to nil")
	}
	{
		if err := i.Flags.Decode(b); err != nil {
			return fmt.Errorf("unable to decode inputRichMessageHTML#dacb836a: field flags: %w", err)
		}
	}
	i.Rtl = i.Flags.Has(0)
	i.Noautolink = i.Flags.Has(1)
	{
		value, err := b.String()
		if err != nil {
			return fmt.Errorf("unable to decode inputRichMessageHTML#dacb836a: field html: %w", err)
		}
		i.HTML = value
	}
	if i.Flags.Has(2) {
		headerLen, err := b.VectorHeader()
		if err != nil {
			return fmt.Errorf("unable to decode inputRichMessageHTML#dacb836a: field files: %w", err)
		}

		if headerLen > 0 {
			i.Files = make([]InputRichFileClass, 0, headerLen%bin.PreallocateLimit)
		}
		for idx := 0; idx < headerLen; idx++ {
			value, err := DecodeInputRichFile(b)
			if err != nil {
				return fmt.Errorf("unable to decode inputRichMessageHTML#dacb836a: field files: %w", err)
			}
			i.Files = append(i.Files, value)
		}
	}
	return nil
}

// SetRtl sets value of Rtl conditional field.
func (i *InputRichMessageHTML) SetRtl(value bool) {
	if value {
		i.Flags.Set(0)
		i.Rtl = true
	} else {
		i.Flags.Unset(0)
		i.Rtl = false
	}
}

// GetRtl returns value of Rtl conditional field.
func (i *InputRichMessageHTML) GetRtl() (value bool) {
	if i == nil {
		return
	}
	return i.Flags.Has(0)
}

// SetNoautolink sets value of Noautolink conditional field.
func (i *InputRichMessageHTML) SetNoautolink(value bool) {
	if value {
		i.Flags.Set(1)
		i.Noautolink = true
	} else {
		i.Flags.Unset(1)
		i.Noautolink = false
	}
}

// GetNoautolink returns value of Noautolink conditional field.
func (i *InputRichMessageHTML) GetNoautolink() (value bool) {
	if i == nil {
		return
	}
	return i.Flags.Has(1)
}

// GetHTML returns value of HTML field.
func (i *InputRichMessageHTML) GetHTML() (value string) {
	if i == nil {
		return
	}
	return i.HTML
}

// SetFiles sets value of Files conditional field.
func (i *InputRichMessageHTML) SetFiles(value []InputRichFileClass) {
	i.Flags.Set(2)
	i.Files = value
}

// GetFiles returns value of Files conditional field and
// boolean which is true if field was set.
func (i *InputRichMessageHTML) GetFiles() (value []InputRichFileClass, ok bool) {
	if i == nil {
		return
	}
	if !i.Flags.Has(2) {
		return value, false
	}
	return i.Files, true
}

// MapFiles returns field Files wrapped in InputRichFileClassArray helper.
func (i *InputRichMessageHTML) MapFiles() (value InputRichFileClassArray, ok bool) {
	if !i.Flags.Has(2) {
		return value, false
	}
	return InputRichFileClassArray(i.Files), true
}

// InputRichMessageMarkdown represents TL type `inputRichMessageMarkdown#4b572c`.
//
// See https://core.telegram.org/constructor/inputRichMessageMarkdown for reference.
type InputRichMessageMarkdown struct {
	// Flags field of InputRichMessageMarkdown.
	Flags bin.Fields
	// Rtl field of InputRichMessageMarkdown.
	Rtl bool
	// Noautolink field of InputRichMessageMarkdown.
	Noautolink bool
	// Markdown field of InputRichMessageMarkdown.
	Markdown string
	// Files field of InputRichMessageMarkdown.
	//
	// Use SetFiles and GetFiles helpers.
	Files []InputRichFileClass
}

// InputRichMessageMarkdownTypeID is TL type id of InputRichMessageMarkdown.
const InputRichMessageMarkdownTypeID = 0x4b572c

// construct implements constructor of InputRichMessageClass.
func (i InputRichMessageMarkdown) construct() InputRichMessageClass { return &i }

// Ensuring interfaces in compile-time for InputRichMessageMarkdown.
var (
	_ bin.Encoder     = &InputRichMessageMarkdown{}
	_ bin.Decoder     = &InputRichMessageMarkdown{}
	_ bin.BareEncoder = &InputRichMessageMarkdown{}
	_ bin.BareDecoder = &InputRichMessageMarkdown{}

	_ InputRichMessageClass = &InputRichMessageMarkdown{}
)

func (i *InputRichMessageMarkdown) Zero() bool {
	if i == nil {
		return true
	}
	if !(i.Flags.Zero()) {
		return false
	}
	if !(i.Rtl == false) {
		return false
	}
	if !(i.Noautolink == false) {
		return false
	}
	if !(i.Markdown == "") {
		return false
	}
	if !(i.Files == nil) {
		return false
	}

	return true
}

// String implements fmt.Stringer.
func (i *InputRichMessageMarkdown) String() string {
	if i == nil {
		return "InputRichMessageMarkdown(nil)"
	}
	type Alias InputRichMessageMarkdown
	return fmt.Sprintf("InputRichMessageMarkdown%+v", Alias(*i))
}

// FillFrom fills InputRichMessageMarkdown from given interface.
func (i *InputRichMessageMarkdown) FillFrom(from interface {
	GetRtl() (value bool)
	GetNoautolink() (value bool)
	GetMarkdown() (value string)
	GetFiles() (value []InputRichFileClass, ok bool)
}) {
	i.Rtl = from.GetRtl()
	i.Noautolink = from.GetNoautolink()
	i.Markdown = from.GetMarkdown()
	if val, ok := from.GetFiles(); ok {
		i.Files = val
	}

}

// TypeID returns type id in TL schema.
//
// See https://core.telegram.org/mtproto/TL-tl#remarks.
func (*InputRichMessageMarkdown) TypeID() uint32 {
	return InputRichMessageMarkdownTypeID
}

// TypeName returns name of type in TL schema.
func (*InputRichMessageMarkdown) TypeName() string {
	return "inputRichMessageMarkdown"
}

// TypeInfo returns info about TL type.
func (i *InputRichMessageMarkdown) TypeInfo() tdp.Type {
	typ := tdp.Type{
		Name: "inputRichMessageMarkdown",
		ID:   InputRichMessageMarkdownTypeID,
	}
	if i == nil {
		typ.Null = true
		return typ
	}
	typ.Fields = []tdp.Field{
		{
			Name:       "Rtl",
			SchemaName: "rtl",
			Null:       !i.Flags.Has(0),
		},
		{
			Name:       "Noautolink",
			SchemaName: "noautolink",
			Null:       !i.Flags.Has(1),
		},
		{
			Name:       "Markdown",
			SchemaName: "markdown",
		},
		{
			Name:       "Files",
			SchemaName: "files",
			Null:       !i.Flags.Has(2),
		},
	}
	return typ
}

// SetFlags sets flags for non-zero fields.
func (i *InputRichMessageMarkdown) SetFlags() {
	if !(i.Rtl == false) {
		i.Flags.Set(0)
	}
	if !(i.Noautolink == false) {
		i.Flags.Set(1)
	}
	if !(i.Files == nil) {
		i.Flags.Set(2)
	}
}

// Encode implements bin.Encoder.
func (i *InputRichMessageMarkdown) Encode(b *bin.Buffer) error {
	if i == nil {
		return fmt.Errorf("can't encode inputRichMessageMarkdown#4b572c as nil")
	}
	b.PutID(InputRichMessageMarkdownTypeID)
	return i.EncodeBare(b)
}

// EncodeBare implements bin.BareEncoder.
func (i *InputRichMessageMarkdown) EncodeBare(b *bin.Buffer) error {
	if i == nil {
		return fmt.Errorf("can't encode inputRichMessageMarkdown#4b572c as nil")
	}
	i.SetFlags()
	if err := i.Flags.Encode(b); err != nil {
		return fmt.Errorf("unable to encode inputRichMessageMarkdown#4b572c: field flags: %w", err)
	}
	b.PutString(i.Markdown)
	if i.Flags.Has(2) {
		b.PutVectorHeader(len(i.Files))
		for idx, v := range i.Files {
			if v == nil {
				return fmt.Errorf("unable to encode inputRichMessageMarkdown#4b572c: field files element with index %d is nil", idx)
			}
			if err := v.Encode(b); err != nil {
				return fmt.Errorf("unable to encode inputRichMessageMarkdown#4b572c: field files element with index %d: %w", idx, err)
			}
		}
	}
	return nil
}

// Decode implements bin.Decoder.
func (i *InputRichMessageMarkdown) Decode(b *bin.Buffer) error {
	if i == nil {
		return fmt.Errorf("can't decode inputRichMessageMarkdown#4b572c to nil")
	}
	if err := b.ConsumeID(InputRichMessageMarkdownTypeID); err != nil {
		return fmt.Errorf("unable to decode inputRichMessageMarkdown#4b572c: %w", err)
	}
	return i.DecodeBare(b)
}

// DecodeBare implements bin.BareDecoder.
func (i *InputRichMessageMarkdown) DecodeBare(b *bin.Buffer) error {
	if i == nil {
		return fmt.Errorf("can't decode inputRichMessageMarkdown#4b572c to nil")
	}
	{
		if err := i.Flags.Decode(b); err != nil {
			return fmt.Errorf("unable to decode inputRichMessageMarkdown#4b572c: field flags: %w", err)
		}
	}
	i.Rtl = i.Flags.Has(0)
	i.Noautolink = i.Flags.Has(1)
	{
		value, err := b.String()
		if err != nil {
			return fmt.Errorf("unable to decode inputRichMessageMarkdown#4b572c: field markdown: %w", err)
		}
		i.Markdown = value
	}
	if i.Flags.Has(2) {
		headerLen, err := b.VectorHeader()
		if err != nil {
			return fmt.Errorf("unable to decode inputRichMessageMarkdown#4b572c: field files: %w", err)
		}

		if headerLen > 0 {
			i.Files = make([]InputRichFileClass, 0, headerLen%bin.PreallocateLimit)
		}
		for idx := 0; idx < headerLen; idx++ {
			value, err := DecodeInputRichFile(b)
			if err != nil {
				return fmt.Errorf("unable to decode inputRichMessageMarkdown#4b572c: field files: %w", err)
			}
			i.Files = append(i.Files, value)
		}
	}
	return nil
}

// SetRtl sets value of Rtl conditional field.
func (i *InputRichMessageMarkdown) SetRtl(value bool) {
	if value {
		i.Flags.Set(0)
		i.Rtl = true
	} else {
		i.Flags.Unset(0)
		i.Rtl = false
	}
}

// GetRtl returns value of Rtl conditional field.
func (i *InputRichMessageMarkdown) GetRtl() (value bool) {
	if i == nil {
		return
	}
	return i.Flags.Has(0)
}

// SetNoautolink sets value of Noautolink conditional field.
func (i *InputRichMessageMarkdown) SetNoautolink(value bool) {
	if value {
		i.Flags.Set(1)
		i.Noautolink = true
	} else {
		i.Flags.Unset(1)
		i.Noautolink = false
	}
}

// GetNoautolink returns value of Noautolink conditional field.
func (i *InputRichMessageMarkdown) GetNoautolink() (value bool) {
	if i == nil {
		return
	}
	return i.Flags.Has(1)
}

// GetMarkdown returns value of Markdown field.
func (i *InputRichMessageMarkdown) GetMarkdown() (value string) {
	if i == nil {
		return
	}
	return i.Markdown
}

// SetFiles sets value of Files conditional field.
func (i *InputRichMessageMarkdown) SetFiles(value []InputRichFileClass) {
	i.Flags.Set(2)
	i.Files = value
}

// GetFiles returns value of Files conditional field and
// boolean which is true if field was set.
func (i *InputRichMessageMarkdown) GetFiles() (value []InputRichFileClass, ok bool) {
	if i == nil {
		return
	}
	if !i.Flags.Has(2) {
		return value, false
	}
	return i.Files, true
}

// MapFiles returns field Files wrapped in InputRichFileClassArray helper.
func (i *InputRichMessageMarkdown) MapFiles() (value InputRichFileClassArray, ok bool) {
	if !i.Flags.Has(2) {
		return value, false
	}
	return InputRichFileClassArray(i.Files), true
}

// InputRichMessageClassName is schema name of InputRichMessageClass.
const InputRichMessageClassName = "InputRichMessage"

// InputRichMessageClass represents InputRichMessage generic type.
//
// See https://core.telegram.org/type/InputRichMessage for reference.
//
// Constructors:
//   - [InputRichMessage]
//   - [InputRichMessageHTML]
//   - [InputRichMessageMarkdown]
//
// Example:
//
//	g, err := tg.DecodeInputRichMessage(buf)
//	if err != nil {
//	    panic(err)
//	}
//	switch v := g.(type) {
//	case *tg.InputRichMessage: // inputRichMessage#e4c449fc
//	case *tg.InputRichMessageHTML: // inputRichMessageHTML#dacb836a
//	case *tg.InputRichMessageMarkdown: // inputRichMessageMarkdown#4b572c
//	default: panic(v)
//	}
type InputRichMessageClass interface {
	bin.Encoder
	bin.Decoder
	bin.BareEncoder
	bin.BareDecoder
	construct() InputRichMessageClass

	// TypeID returns type id in TL schema.
	//
	// See https://core.telegram.org/mtproto/TL-tl#remarks.
	TypeID() uint32
	// TypeName returns name of type in TL schema.
	TypeName() string
	// String implements fmt.Stringer.
	String() string
	// Zero returns true if current object has a zero value.
	Zero() bool

	// Rtl field of InputRichMessage.
	GetRtl() (value bool)

	// Noautolink field of InputRichMessage.
	GetNoautolink() (value bool)
}

// DecodeInputRichMessage implements binary de-serialization for InputRichMessageClass.
func DecodeInputRichMessage(buf *bin.Buffer) (InputRichMessageClass, error) {
	id, err := buf.PeekID()
	if err != nil {
		return nil, err
	}
	switch id {
	case InputRichMessageTypeID:
		// Decoding inputRichMessage#e4c449fc.
		v := InputRichMessage{}
		if err := v.Decode(buf); err != nil {
			return nil, fmt.Errorf("unable to decode InputRichMessageClass: %w", err)
		}
		return &v, nil
	case InputRichMessageHTMLTypeID:
		// Decoding inputRichMessageHTML#dacb836a.
		v := InputRichMessageHTML{}
		if err := v.Decode(buf); err != nil {
			return nil, fmt.Errorf("unable to decode InputRichMessageClass: %w", err)
		}
		return &v, nil
	case InputRichMessageMarkdownTypeID:
		// Decoding inputRichMessageMarkdown#4b572c.
		v := InputRichMessageMarkdown{}
		if err := v.Decode(buf); err != nil {
			return nil, fmt.Errorf("unable to decode InputRichMessageClass: %w", err)
		}
		return &v, nil
	default:
		return nil, fmt.Errorf("unable to decode InputRichMessageClass: %w", bin.NewUnexpectedID(id))
	}
}

// InputRichMessage boxes the InputRichMessageClass providing a helper.
type InputRichMessageBox struct {
	InputRichMessage InputRichMessageClass
}

// Decode implements bin.Decoder for InputRichMessageBox.
func (b *InputRichMessageBox) Decode(buf *bin.Buffer) error {
	if b == nil {
		return fmt.Errorf("unable to decode InputRichMessageBox to nil")
	}
	v, err := DecodeInputRichMessage(buf)
	if err != nil {
		return fmt.Errorf("unable to decode boxed value: %w", err)
	}
	b.InputRichMessage = v
	return nil
}

// Encode implements bin.Encode for InputRichMessageBox.
func (b *InputRichMessageBox) Encode(buf *bin.Buffer) error {
	if b == nil || b.InputRichMessage == nil {
		return fmt.Errorf("unable to encode InputRichMessageClass as nil")
	}
	return b.InputRichMessage.Encode(buf)
}

The pages are generated with Golds v0.8.4. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @zigo_101 (reachable from the left QR code) to get the latest news of Golds.