Source File
	tl_rich_text_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{}
)

// TextEmpty represents TL type `textEmpty#dc3d824f`.
// Empty rich text element
//
// See https://core.telegram.org/constructor/textEmpty for reference.
type TextEmpty struct {
}

// TextEmptyTypeID is TL type id of TextEmpty.
const TextEmptyTypeID = 0xdc3d824f

// construct implements constructor of RichTextClass.
func (t TextEmpty) construct() RichTextClass { return &t }

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

	_ RichTextClass = &TextEmpty{}
)

func (t *TextEmpty) Zero() bool {
	if t == nil {
		return true
	}

	return true
}

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

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

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

// TypeInfo returns info about TL type.
func (t *TextEmpty) TypeInfo() tdp.Type {
	typ := tdp.Type{
		Name: "textEmpty",
		ID:   TextEmptyTypeID,
	}
	if t == nil {
		typ.Null = true
		return typ
	}
	typ.Fields = []tdp.Field{}
	return typ
}

// Encode implements bin.Encoder.
func (t *TextEmpty) Encode(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't encode textEmpty#dc3d824f as nil")
	}
	b.PutID(TextEmptyTypeID)
	return t.EncodeBare(b)
}

// EncodeBare implements bin.BareEncoder.
func (t *TextEmpty) EncodeBare(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't encode textEmpty#dc3d824f as nil")
	}
	return nil
}

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

// DecodeBare implements bin.BareDecoder.
func (t *TextEmpty) DecodeBare(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't decode textEmpty#dc3d824f to nil")
	}
	return nil
}

// TextPlain represents TL type `textPlain#744694e0`.
// Plain text
//
// See https://core.telegram.org/constructor/textPlain for reference.
type TextPlain struct {
	// Text
	Text string
}

// TextPlainTypeID is TL type id of TextPlain.
const TextPlainTypeID = 0x744694e0

// construct implements constructor of RichTextClass.
func (t TextPlain) construct() RichTextClass { return &t }

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

	_ RichTextClass = &TextPlain{}
)

func (t *TextPlain) Zero() bool {
	if t == nil {
		return true
	}
	if !(t.Text == "") {
		return false
	}

	return true
}

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

// FillFrom fills TextPlain from given interface.
func (t *TextPlain) FillFrom(from interface {
	GetText() (value string)
}) {
	t.Text = from.GetText()
}

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

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

// TypeInfo returns info about TL type.
func (t *TextPlain) TypeInfo() tdp.Type {
	typ := tdp.Type{
		Name: "textPlain",
		ID:   TextPlainTypeID,
	}
	if t == nil {
		typ.Null = true
		return typ
	}
	typ.Fields = []tdp.Field{
		{
			Name:       "Text",
			SchemaName: "text",
		},
	}
	return typ
}

// Encode implements bin.Encoder.
func (t *TextPlain) Encode(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't encode textPlain#744694e0 as nil")
	}
	b.PutID(TextPlainTypeID)
	return t.EncodeBare(b)
}

// EncodeBare implements bin.BareEncoder.
func (t *TextPlain) EncodeBare(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't encode textPlain#744694e0 as nil")
	}
	b.PutString(t.Text)
	return nil
}

// Decode implements bin.Decoder.
func (t *TextPlain) Decode(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't decode textPlain#744694e0 to nil")
	}
	if err := b.ConsumeID(TextPlainTypeID); err != nil {
		return fmt.Errorf("unable to decode textPlain#744694e0: %w", err)
	}
	return t.DecodeBare(b)
}

// DecodeBare implements bin.BareDecoder.
func (t *TextPlain) DecodeBare(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't decode textPlain#744694e0 to nil")
	}
	{
		value, err := b.String()
		if err != nil {
			return fmt.Errorf("unable to decode textPlain#744694e0: field text: %w", err)
		}
		t.Text = value
	}
	return nil
}

// GetText returns value of Text field.
func (t *TextPlain) GetText() (value string) {
	if t == nil {
		return
	}
	return t.Text
}

// TextBold represents TL type `textBold#6724abc4`.
// Bold text
//
// See https://core.telegram.org/constructor/textBold for reference.
type TextBold struct {
	// Text
	Text RichTextClass
}

// TextBoldTypeID is TL type id of TextBold.
const TextBoldTypeID = 0x6724abc4

// construct implements constructor of RichTextClass.
func (t TextBold) construct() RichTextClass { return &t }

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

	_ RichTextClass = &TextBold{}
)

func (t *TextBold) Zero() bool {
	if t == nil {
		return true
	}
	if !(t.Text == nil) {
		return false
	}

	return true
}

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

// FillFrom fills TextBold from given interface.
func (t *TextBold) FillFrom(from interface {
	GetText() (value RichTextClass)
}) {
	t.Text = from.GetText()
}

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

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

// TypeInfo returns info about TL type.
func (t *TextBold) TypeInfo() tdp.Type {
	typ := tdp.Type{
		Name: "textBold",
		ID:   TextBoldTypeID,
	}
	if t == nil {
		typ.Null = true
		return typ
	}
	typ.Fields = []tdp.Field{
		{
			Name:       "Text",
			SchemaName: "text",
		},
	}
	return typ
}

// Encode implements bin.Encoder.
func (t *TextBold) Encode(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't encode textBold#6724abc4 as nil")
	}
	b.PutID(TextBoldTypeID)
	return t.EncodeBare(b)
}

// EncodeBare implements bin.BareEncoder.
func (t *TextBold) EncodeBare(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't encode textBold#6724abc4 as nil")
	}
	if t.Text == nil {
		return fmt.Errorf("unable to encode textBold#6724abc4: field text is nil")
	}
	if err := t.Text.Encode(b); err != nil {
		return fmt.Errorf("unable to encode textBold#6724abc4: field text: %w", err)
	}
	return nil
}

// Decode implements bin.Decoder.
func (t *TextBold) Decode(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't decode textBold#6724abc4 to nil")
	}
	if err := b.ConsumeID(TextBoldTypeID); err != nil {
		return fmt.Errorf("unable to decode textBold#6724abc4: %w", err)
	}
	return t.DecodeBare(b)
}

// DecodeBare implements bin.BareDecoder.
func (t *TextBold) DecodeBare(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't decode textBold#6724abc4 to nil")
	}
	{
		value, err := DecodeRichText(b)
		if err != nil {
			return fmt.Errorf("unable to decode textBold#6724abc4: field text: %w", err)
		}
		t.Text = value
	}
	return nil
}

// GetText returns value of Text field.
func (t *TextBold) GetText() (value RichTextClass) {
	if t == nil {
		return
	}
	return t.Text
}

// TextItalic represents TL type `textItalic#d912a59c`.
// Italic text
//
// See https://core.telegram.org/constructor/textItalic for reference.
type TextItalic struct {
	// Text
	Text RichTextClass
}

// TextItalicTypeID is TL type id of TextItalic.
const TextItalicTypeID = 0xd912a59c

// construct implements constructor of RichTextClass.
func (t TextItalic) construct() RichTextClass { return &t }

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

	_ RichTextClass = &TextItalic{}
)

func (t *TextItalic) Zero() bool {
	if t == nil {
		return true
	}
	if !(t.Text == nil) {
		return false
	}

	return true
}

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

// FillFrom fills TextItalic from given interface.
func (t *TextItalic) FillFrom(from interface {
	GetText() (value RichTextClass)
}) {
	t.Text = from.GetText()
}

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

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

// TypeInfo returns info about TL type.
func (t *TextItalic) TypeInfo() tdp.Type {
	typ := tdp.Type{
		Name: "textItalic",
		ID:   TextItalicTypeID,
	}
	if t == nil {
		typ.Null = true
		return typ
	}
	typ.Fields = []tdp.Field{
		{
			Name:       "Text",
			SchemaName: "text",
		},
	}
	return typ
}

// Encode implements bin.Encoder.
func (t *TextItalic) Encode(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't encode textItalic#d912a59c as nil")
	}
	b.PutID(TextItalicTypeID)
	return t.EncodeBare(b)
}

// EncodeBare implements bin.BareEncoder.
func (t *TextItalic) EncodeBare(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't encode textItalic#d912a59c as nil")
	}
	if t.Text == nil {
		return fmt.Errorf("unable to encode textItalic#d912a59c: field text is nil")
	}
	if err := t.Text.Encode(b); err != nil {
		return fmt.Errorf("unable to encode textItalic#d912a59c: field text: %w", err)
	}
	return nil
}

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

// DecodeBare implements bin.BareDecoder.
func (t *TextItalic) DecodeBare(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't decode textItalic#d912a59c to nil")
	}
	{
		value, err := DecodeRichText(b)
		if err != nil {
			return fmt.Errorf("unable to decode textItalic#d912a59c: field text: %w", err)
		}
		t.Text = value
	}
	return nil
}

// GetText returns value of Text field.
func (t *TextItalic) GetText() (value RichTextClass) {
	if t == nil {
		return
	}
	return t.Text
}

// TextUnderline represents TL type `textUnderline#c12622c4`.
// Underlined text
//
// See https://core.telegram.org/constructor/textUnderline for reference.
type TextUnderline struct {
	// Text
	Text RichTextClass
}

// TextUnderlineTypeID is TL type id of TextUnderline.
const TextUnderlineTypeID = 0xc12622c4

// construct implements constructor of RichTextClass.
func (t TextUnderline) construct() RichTextClass { return &t }

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

	_ RichTextClass = &TextUnderline{}
)

func (t *TextUnderline) Zero() bool {
	if t == nil {
		return true
	}
	if !(t.Text == nil) {
		return false
	}

	return true
}

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

// FillFrom fills TextUnderline from given interface.
func (t *TextUnderline) FillFrom(from interface {
	GetText() (value RichTextClass)
}) {
	t.Text = from.GetText()
}

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

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

// TypeInfo returns info about TL type.
func (t *TextUnderline) TypeInfo() tdp.Type {
	typ := tdp.Type{
		Name: "textUnderline",
		ID:   TextUnderlineTypeID,
	}
	if t == nil {
		typ.Null = true
		return typ
	}
	typ.Fields = []tdp.Field{
		{
			Name:       "Text",
			SchemaName: "text",
		},
	}
	return typ
}

// Encode implements bin.Encoder.
func (t *TextUnderline) Encode(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't encode textUnderline#c12622c4 as nil")
	}
	b.PutID(TextUnderlineTypeID)
	return t.EncodeBare(b)
}

// EncodeBare implements bin.BareEncoder.
func (t *TextUnderline) EncodeBare(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't encode textUnderline#c12622c4 as nil")
	}
	if t.Text == nil {
		return fmt.Errorf("unable to encode textUnderline#c12622c4: field text is nil")
	}
	if err := t.Text.Encode(b); err != nil {
		return fmt.Errorf("unable to encode textUnderline#c12622c4: field text: %w", err)
	}
	return nil
}

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

// DecodeBare implements bin.BareDecoder.
func (t *TextUnderline) DecodeBare(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't decode textUnderline#c12622c4 to nil")
	}
	{
		value, err := DecodeRichText(b)
		if err != nil {
			return fmt.Errorf("unable to decode textUnderline#c12622c4: field text: %w", err)
		}
		t.Text = value
	}
	return nil
}

// GetText returns value of Text field.
func (t *TextUnderline) GetText() (value RichTextClass) {
	if t == nil {
		return
	}
	return t.Text
}

// TextStrike represents TL type `textStrike#9bf8bb95`.
// Strikethrough text
//
// See https://core.telegram.org/constructor/textStrike for reference.
type TextStrike struct {
	// Text
	Text RichTextClass
}

// TextStrikeTypeID is TL type id of TextStrike.
const TextStrikeTypeID = 0x9bf8bb95

// construct implements constructor of RichTextClass.
func (t TextStrike) construct() RichTextClass { return &t }

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

	_ RichTextClass = &TextStrike{}
)

func (t *TextStrike) Zero() bool {
	if t == nil {
		return true
	}
	if !(t.Text == nil) {
		return false
	}

	return true
}

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

// FillFrom fills TextStrike from given interface.
func (t *TextStrike) FillFrom(from interface {
	GetText() (value RichTextClass)
}) {
	t.Text = from.GetText()
}

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

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

// TypeInfo returns info about TL type.
func (t *TextStrike) TypeInfo() tdp.Type {
	typ := tdp.Type{
		Name: "textStrike",
		ID:   TextStrikeTypeID,
	}
	if t == nil {
		typ.Null = true
		return typ
	}
	typ.Fields = []tdp.Field{
		{
			Name:       "Text",
			SchemaName: "text",
		},
	}
	return typ
}

// Encode implements bin.Encoder.
func (t *TextStrike) Encode(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't encode textStrike#9bf8bb95 as nil")
	}
	b.PutID(TextStrikeTypeID)
	return t.EncodeBare(b)
}

// EncodeBare implements bin.BareEncoder.
func (t *TextStrike) EncodeBare(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't encode textStrike#9bf8bb95 as nil")
	}
	if t.Text == nil {
		return fmt.Errorf("unable to encode textStrike#9bf8bb95: field text is nil")
	}
	if err := t.Text.Encode(b); err != nil {
		return fmt.Errorf("unable to encode textStrike#9bf8bb95: field text: %w", err)
	}
	return nil
}

// Decode implements bin.Decoder.
func (t *TextStrike) Decode(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't decode textStrike#9bf8bb95 to nil")
	}
	if err := b.ConsumeID(TextStrikeTypeID); err != nil {
		return fmt.Errorf("unable to decode textStrike#9bf8bb95: %w", err)
	}
	return t.DecodeBare(b)
}

// DecodeBare implements bin.BareDecoder.
func (t *TextStrike) DecodeBare(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't decode textStrike#9bf8bb95 to nil")
	}
	{
		value, err := DecodeRichText(b)
		if err != nil {
			return fmt.Errorf("unable to decode textStrike#9bf8bb95: field text: %w", err)
		}
		t.Text = value
	}
	return nil
}

// GetText returns value of Text field.
func (t *TextStrike) GetText() (value RichTextClass) {
	if t == nil {
		return
	}
	return t.Text
}

// TextFixed represents TL type `textFixed#6c3f19b9`.
// fixed-width rich text
//
// See https://core.telegram.org/constructor/textFixed for reference.
type TextFixed struct {
	// Text
	Text RichTextClass
}

// TextFixedTypeID is TL type id of TextFixed.
const TextFixedTypeID = 0x6c3f19b9

// construct implements constructor of RichTextClass.
func (t TextFixed) construct() RichTextClass { return &t }

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

	_ RichTextClass = &TextFixed{}
)

func (t *TextFixed) Zero() bool {
	if t == nil {
		return true
	}
	if !(t.Text == nil) {
		return false
	}

	return true
}

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

// FillFrom fills TextFixed from given interface.
func (t *TextFixed) FillFrom(from interface {
	GetText() (value RichTextClass)
}) {
	t.Text = from.GetText()
}

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

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

// TypeInfo returns info about TL type.
func (t *TextFixed) TypeInfo() tdp.Type {
	typ := tdp.Type{
		Name: "textFixed",
		ID:   TextFixedTypeID,
	}
	if t == nil {
		typ.Null = true
		return typ
	}
	typ.Fields = []tdp.Field{
		{
			Name:       "Text",
			SchemaName: "text",
		},
	}
	return typ
}

// Encode implements bin.Encoder.
func (t *TextFixed) Encode(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't encode textFixed#6c3f19b9 as nil")
	}
	b.PutID(TextFixedTypeID)
	return t.EncodeBare(b)
}

// EncodeBare implements bin.BareEncoder.
func (t *TextFixed) EncodeBare(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't encode textFixed#6c3f19b9 as nil")
	}
	if t.Text == nil {
		return fmt.Errorf("unable to encode textFixed#6c3f19b9: field text is nil")
	}
	if err := t.Text.Encode(b); err != nil {
		return fmt.Errorf("unable to encode textFixed#6c3f19b9: field text: %w", err)
	}
	return nil
}

// Decode implements bin.Decoder.
func (t *TextFixed) Decode(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't decode textFixed#6c3f19b9 to nil")
	}
	if err := b.ConsumeID(TextFixedTypeID); err != nil {
		return fmt.Errorf("unable to decode textFixed#6c3f19b9: %w", err)
	}
	return t.DecodeBare(b)
}

// DecodeBare implements bin.BareDecoder.
func (t *TextFixed) DecodeBare(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't decode textFixed#6c3f19b9 to nil")
	}
	{
		value, err := DecodeRichText(b)
		if err != nil {
			return fmt.Errorf("unable to decode textFixed#6c3f19b9: field text: %w", err)
		}
		t.Text = value
	}
	return nil
}

// GetText returns value of Text field.
func (t *TextFixed) GetText() (value RichTextClass) {
	if t == nil {
		return
	}
	return t.Text
}

// TextURL represents TL type `textUrl#3c2884c1`.
// Link
//
// See https://core.telegram.org/constructor/textUrl for reference.
type TextURL struct {
	// Text of link
	Text RichTextClass
	// Webpage HTTP URL
	URL string
	// If a preview was already generated for the page, the page ID
	WebpageID int64
}

// TextURLTypeID is TL type id of TextURL.
const TextURLTypeID = 0x3c2884c1

// construct implements constructor of RichTextClass.
func (t TextURL) construct() RichTextClass { return &t }

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

	_ RichTextClass = &TextURL{}
)

func (t *TextURL) Zero() bool {
	if t == nil {
		return true
	}
	if !(t.Text == nil) {
		return false
	}
	if !(t.URL == "") {
		return false
	}
	if !(t.WebpageID == 0) {
		return false
	}

	return true
}

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

// FillFrom fills TextURL from given interface.
func (t *TextURL) FillFrom(from interface {
	GetText() (value RichTextClass)
	GetURL() (value string)
	GetWebpageID() (value int64)
}) {
	t.Text = from.GetText()
	t.URL = from.GetURL()
	t.WebpageID = from.GetWebpageID()
}

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

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

// TypeInfo returns info about TL type.
func (t *TextURL) TypeInfo() tdp.Type {
	typ := tdp.Type{
		Name: "textUrl",
		ID:   TextURLTypeID,
	}
	if t == nil {
		typ.Null = true
		return typ
	}
	typ.Fields = []tdp.Field{
		{
			Name:       "Text",
			SchemaName: "text",
		},
		{
			Name:       "URL",
			SchemaName: "url",
		},
		{
			Name:       "WebpageID",
			SchemaName: "webpage_id",
		},
	}
	return typ
}

// Encode implements bin.Encoder.
func (t *TextURL) Encode(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't encode textUrl#3c2884c1 as nil")
	}
	b.PutID(TextURLTypeID)
	return t.EncodeBare(b)
}

// EncodeBare implements bin.BareEncoder.
func (t *TextURL) EncodeBare(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't encode textUrl#3c2884c1 as nil")
	}
	if t.Text == nil {
		return fmt.Errorf("unable to encode textUrl#3c2884c1: field text is nil")
	}
	if err := t.Text.Encode(b); err != nil {
		return fmt.Errorf("unable to encode textUrl#3c2884c1: field text: %w", err)
	}
	b.PutString(t.URL)
	b.PutLong(t.WebpageID)
	return nil
}

// Decode implements bin.Decoder.
func (t *TextURL) Decode(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't decode textUrl#3c2884c1 to nil")
	}
	if err := b.ConsumeID(TextURLTypeID); err != nil {
		return fmt.Errorf("unable to decode textUrl#3c2884c1: %w", err)
	}
	return t.DecodeBare(b)
}

// DecodeBare implements bin.BareDecoder.
func (t *TextURL) DecodeBare(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't decode textUrl#3c2884c1 to nil")
	}
	{
		value, err := DecodeRichText(b)
		if err != nil {
			return fmt.Errorf("unable to decode textUrl#3c2884c1: field text: %w", err)
		}
		t.Text = value
	}
	{
		value, err := b.String()
		if err != nil {
			return fmt.Errorf("unable to decode textUrl#3c2884c1: field url: %w", err)
		}
		t.URL = value
	}
	{
		value, err := b.Long()
		if err != nil {
			return fmt.Errorf("unable to decode textUrl#3c2884c1: field webpage_id: %w", err)
		}
		t.WebpageID = value
	}
	return nil
}

// GetText returns value of Text field.
func (t *TextURL) GetText() (value RichTextClass) {
	if t == nil {
		return
	}
	return t.Text
}

// GetURL returns value of URL field.
func (t *TextURL) GetURL() (value string) {
	if t == nil {
		return
	}
	return t.URL
}

// GetWebpageID returns value of WebpageID field.
func (t *TextURL) GetWebpageID() (value int64) {
	if t == nil {
		return
	}
	return t.WebpageID
}

// TextEmail represents TL type `textEmail#de5a0dd6`.
// Rich text email link
//
// See https://core.telegram.org/constructor/textEmail for reference.
type TextEmail struct {
	// Link text
	Text RichTextClass
	// Email address
	Email string
}

// TextEmailTypeID is TL type id of TextEmail.
const TextEmailTypeID = 0xde5a0dd6

// construct implements constructor of RichTextClass.
func (t TextEmail) construct() RichTextClass { return &t }

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

	_ RichTextClass = &TextEmail{}
)

func (t *TextEmail) Zero() bool {
	if t == nil {
		return true
	}
	if !(t.Text == nil) {
		return false
	}
	if !(t.Email == "") {
		return false
	}

	return true
}

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

// FillFrom fills TextEmail from given interface.
func (t *TextEmail) FillFrom(from interface {
	GetText() (value RichTextClass)
	GetEmail() (value string)
}) {
	t.Text = from.GetText()
	t.Email = from.GetEmail()
}

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

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

// TypeInfo returns info about TL type.
func (t *TextEmail) TypeInfo() tdp.Type {
	typ := tdp.Type{
		Name: "textEmail",
		ID:   TextEmailTypeID,
	}
	if t == nil {
		typ.Null = true
		return typ
	}
	typ.Fields = []tdp.Field{
		{
			Name:       "Text",
			SchemaName: "text",
		},
		{
			Name:       "Email",
			SchemaName: "email",
		},
	}
	return typ
}

// Encode implements bin.Encoder.
func (t *TextEmail) Encode(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't encode textEmail#de5a0dd6 as nil")
	}
	b.PutID(TextEmailTypeID)
	return t.EncodeBare(b)
}

// EncodeBare implements bin.BareEncoder.
func (t *TextEmail) EncodeBare(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't encode textEmail#de5a0dd6 as nil")
	}
	if t.Text == nil {
		return fmt.Errorf("unable to encode textEmail#de5a0dd6: field text is nil")
	}
	if err := t.Text.Encode(b); err != nil {
		return fmt.Errorf("unable to encode textEmail#de5a0dd6: field text: %w", err)
	}
	b.PutString(t.Email)
	return nil
}

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

// DecodeBare implements bin.BareDecoder.
func (t *TextEmail) DecodeBare(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't decode textEmail#de5a0dd6 to nil")
	}
	{
		value, err := DecodeRichText(b)
		if err != nil {
			return fmt.Errorf("unable to decode textEmail#de5a0dd6: field text: %w", err)
		}
		t.Text = value
	}
	{
		value, err := b.String()
		if err != nil {
			return fmt.Errorf("unable to decode textEmail#de5a0dd6: field email: %w", err)
		}
		t.Email = value
	}
	return nil
}

// GetText returns value of Text field.
func (t *TextEmail) GetText() (value RichTextClass) {
	if t == nil {
		return
	}
	return t.Text
}

// GetEmail returns value of Email field.
func (t *TextEmail) GetEmail() (value string) {
	if t == nil {
		return
	}
	return t.Email
}

// TextConcat represents TL type `textConcat#7e6260d7`.
// Concatenation of rich texts
//
// See https://core.telegram.org/constructor/textConcat for reference.
type TextConcat struct {
	// Concatenated rich texts
	Texts []RichTextClass
}

// TextConcatTypeID is TL type id of TextConcat.
const TextConcatTypeID = 0x7e6260d7

// construct implements constructor of RichTextClass.
func (t TextConcat) construct() RichTextClass { return &t }

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

	_ RichTextClass = &TextConcat{}
)

func (t *TextConcat) Zero() bool {
	if t == nil {
		return true
	}
	if !(t.Texts == nil) {
		return false
	}

	return true
}

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

// FillFrom fills TextConcat from given interface.
func (t *TextConcat) FillFrom(from interface {
	GetTexts() (value []RichTextClass)
}) {
	t.Texts = from.GetTexts()
}

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

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

// TypeInfo returns info about TL type.
func (t *TextConcat) TypeInfo() tdp.Type {
	typ := tdp.Type{
		Name: "textConcat",
		ID:   TextConcatTypeID,
	}
	if t == nil {
		typ.Null = true
		return typ
	}
	typ.Fields = []tdp.Field{
		{
			Name:       "Texts",
			SchemaName: "texts",
		},
	}
	return typ
}

// Encode implements bin.Encoder.
func (t *TextConcat) Encode(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't encode textConcat#7e6260d7 as nil")
	}
	b.PutID(TextConcatTypeID)
	return t.EncodeBare(b)
}

// EncodeBare implements bin.BareEncoder.
func (t *TextConcat) EncodeBare(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't encode textConcat#7e6260d7 as nil")
	}
	b.PutVectorHeader(len(t.Texts))
	for idx, v := range t.Texts {
		if v == nil {
			return fmt.Errorf("unable to encode textConcat#7e6260d7: field texts element with index %d is nil", idx)
		}
		if err := v.Encode(b); err != nil {
			return fmt.Errorf("unable to encode textConcat#7e6260d7: field texts element with index %d: %w", idx, err)
		}
	}
	return nil
}

// Decode implements bin.Decoder.
func (t *TextConcat) Decode(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't decode textConcat#7e6260d7 to nil")
	}
	if err := b.ConsumeID(TextConcatTypeID); err != nil {
		return fmt.Errorf("unable to decode textConcat#7e6260d7: %w", err)
	}
	return t.DecodeBare(b)
}

// DecodeBare implements bin.BareDecoder.
func (t *TextConcat) DecodeBare(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't decode textConcat#7e6260d7 to nil")
	}
	{
		headerLen, err := b.VectorHeader()
		if err != nil {
			return fmt.Errorf("unable to decode textConcat#7e6260d7: field texts: %w", err)
		}

		if headerLen > 0 {
			t.Texts = make([]RichTextClass, 0, headerLen%bin.PreallocateLimit)
		}
		for idx := 0; idx < headerLen; idx++ {
			value, err := DecodeRichText(b)
			if err != nil {
				return fmt.Errorf("unable to decode textConcat#7e6260d7: field texts: %w", err)
			}
			t.Texts = append(t.Texts, value)
		}
	}
	return nil
}

// GetTexts returns value of Texts field.
func (t *TextConcat) GetTexts() (value []RichTextClass) {
	if t == nil {
		return
	}
	return t.Texts
}

// MapTexts returns field Texts wrapped in RichTextClassArray helper.
func (t *TextConcat) MapTexts() (value RichTextClassArray) {
	return RichTextClassArray(t.Texts)
}

// TextSubscript represents TL type `textSubscript#ed6a8504`.
// Subscript text
//
// See https://core.telegram.org/constructor/textSubscript for reference.
type TextSubscript struct {
	// Text
	Text RichTextClass
}

// TextSubscriptTypeID is TL type id of TextSubscript.
const TextSubscriptTypeID = 0xed6a8504

// construct implements constructor of RichTextClass.
func (t TextSubscript) construct() RichTextClass { return &t }

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

	_ RichTextClass = &TextSubscript{}
)

func (t *TextSubscript) Zero() bool {
	if t == nil {
		return true
	}
	if !(t.Text == nil) {
		return false
	}

	return true
}

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

// FillFrom fills TextSubscript from given interface.
func (t *TextSubscript) FillFrom(from interface {
	GetText() (value RichTextClass)
}) {
	t.Text = from.GetText()
}

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

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

// TypeInfo returns info about TL type.
func (t *TextSubscript) TypeInfo() tdp.Type {
	typ := tdp.Type{
		Name: "textSubscript",
		ID:   TextSubscriptTypeID,
	}
	if t == nil {
		typ.Null = true
		return typ
	}
	typ.Fields = []tdp.Field{
		{
			Name:       "Text",
			SchemaName: "text",
		},
	}
	return typ
}

// Encode implements bin.Encoder.
func (t *TextSubscript) Encode(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't encode textSubscript#ed6a8504 as nil")
	}
	b.PutID(TextSubscriptTypeID)
	return t.EncodeBare(b)
}

// EncodeBare implements bin.BareEncoder.
func (t *TextSubscript) EncodeBare(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't encode textSubscript#ed6a8504 as nil")
	}
	if t.Text == nil {
		return fmt.Errorf("unable to encode textSubscript#ed6a8504: field text is nil")
	}
	if err := t.Text.Encode(b); err != nil {
		return fmt.Errorf("unable to encode textSubscript#ed6a8504: field text: %w", err)
	}
	return nil
}

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

// DecodeBare implements bin.BareDecoder.
func (t *TextSubscript) DecodeBare(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't decode textSubscript#ed6a8504 to nil")
	}
	{
		value, err := DecodeRichText(b)
		if err != nil {
			return fmt.Errorf("unable to decode textSubscript#ed6a8504: field text: %w", err)
		}
		t.Text = value
	}
	return nil
}

// GetText returns value of Text field.
func (t *TextSubscript) GetText() (value RichTextClass) {
	if t == nil {
		return
	}
	return t.Text
}

// TextSuperscript represents TL type `textSuperscript#c7fb5e01`.
// Superscript text
//
// See https://core.telegram.org/constructor/textSuperscript for reference.
type TextSuperscript struct {
	// Text
	Text RichTextClass
}

// TextSuperscriptTypeID is TL type id of TextSuperscript.
const TextSuperscriptTypeID = 0xc7fb5e01

// construct implements constructor of RichTextClass.
func (t TextSuperscript) construct() RichTextClass { return &t }

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

	_ RichTextClass = &TextSuperscript{}
)

func (t *TextSuperscript) Zero() bool {
	if t == nil {
		return true
	}
	if !(t.Text == nil) {
		return false
	}

	return true
}

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

// FillFrom fills TextSuperscript from given interface.
func (t *TextSuperscript) FillFrom(from interface {
	GetText() (value RichTextClass)
}) {
	t.Text = from.GetText()
}

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

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

// TypeInfo returns info about TL type.
func (t *TextSuperscript) TypeInfo() tdp.Type {
	typ := tdp.Type{
		Name: "textSuperscript",
		ID:   TextSuperscriptTypeID,
	}
	if t == nil {
		typ.Null = true
		return typ
	}
	typ.Fields = []tdp.Field{
		{
			Name:       "Text",
			SchemaName: "text",
		},
	}
	return typ
}

// Encode implements bin.Encoder.
func (t *TextSuperscript) Encode(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't encode textSuperscript#c7fb5e01 as nil")
	}
	b.PutID(TextSuperscriptTypeID)
	return t.EncodeBare(b)
}

// EncodeBare implements bin.BareEncoder.
func (t *TextSuperscript) EncodeBare(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't encode textSuperscript#c7fb5e01 as nil")
	}
	if t.Text == nil {
		return fmt.Errorf("unable to encode textSuperscript#c7fb5e01: field text is nil")
	}
	if err := t.Text.Encode(b); err != nil {
		return fmt.Errorf("unable to encode textSuperscript#c7fb5e01: field text: %w", err)
	}
	return nil
}

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

// DecodeBare implements bin.BareDecoder.
func (t *TextSuperscript) DecodeBare(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't decode textSuperscript#c7fb5e01 to nil")
	}
	{
		value, err := DecodeRichText(b)
		if err != nil {
			return fmt.Errorf("unable to decode textSuperscript#c7fb5e01: field text: %w", err)
		}
		t.Text = value
	}
	return nil
}

// GetText returns value of Text field.
func (t *TextSuperscript) GetText() (value RichTextClass) {
	if t == nil {
		return
	}
	return t.Text
}

// TextMarked represents TL type `textMarked#34b8621`.
// Highlighted text
//
// See https://core.telegram.org/constructor/textMarked for reference.
type TextMarked struct {
	// Text
	Text RichTextClass
}

// TextMarkedTypeID is TL type id of TextMarked.
const TextMarkedTypeID = 0x34b8621

// construct implements constructor of RichTextClass.
func (t TextMarked) construct() RichTextClass { return &t }

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

	_ RichTextClass = &TextMarked{}
)

func (t *TextMarked) Zero() bool {
	if t == nil {
		return true
	}
	if !(t.Text == nil) {
		return false
	}

	return true
}

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

// FillFrom fills TextMarked from given interface.
func (t *TextMarked) FillFrom(from interface {
	GetText() (value RichTextClass)
}) {
	t.Text = from.GetText()
}

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

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

// TypeInfo returns info about TL type.
func (t *TextMarked) TypeInfo() tdp.Type {
	typ := tdp.Type{
		Name: "textMarked",
		ID:   TextMarkedTypeID,
	}
	if t == nil {
		typ.Null = true
		return typ
	}
	typ.Fields = []tdp.Field{
		{
			Name:       "Text",
			SchemaName: "text",
		},
	}
	return typ
}

// Encode implements bin.Encoder.
func (t *TextMarked) Encode(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't encode textMarked#34b8621 as nil")
	}
	b.PutID(TextMarkedTypeID)
	return t.EncodeBare(b)
}

// EncodeBare implements bin.BareEncoder.
func (t *TextMarked) EncodeBare(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't encode textMarked#34b8621 as nil")
	}
	if t.Text == nil {
		return fmt.Errorf("unable to encode textMarked#34b8621: field text is nil")
	}
	if err := t.Text.Encode(b); err != nil {
		return fmt.Errorf("unable to encode textMarked#34b8621: field text: %w", err)
	}
	return nil
}

// Decode implements bin.Decoder.
func (t *TextMarked) Decode(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't decode textMarked#34b8621 to nil")
	}
	if err := b.ConsumeID(TextMarkedTypeID); err != nil {
		return fmt.Errorf("unable to decode textMarked#34b8621: %w", err)
	}
	return t.DecodeBare(b)
}

// DecodeBare implements bin.BareDecoder.
func (t *TextMarked) DecodeBare(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't decode textMarked#34b8621 to nil")
	}
	{
		value, err := DecodeRichText(b)
		if err != nil {
			return fmt.Errorf("unable to decode textMarked#34b8621: field text: %w", err)
		}
		t.Text = value
	}
	return nil
}

// GetText returns value of Text field.
func (t *TextMarked) GetText() (value RichTextClass) {
	if t == nil {
		return
	}
	return t.Text
}

// TextPhone represents TL type `textPhone#1ccb966a`.
// Rich text linked to a phone number
//
// See https://core.telegram.org/constructor/textPhone for reference.
type TextPhone struct {
	// Text
	Text RichTextClass
	// Phone number
	Phone string
}

// TextPhoneTypeID is TL type id of TextPhone.
const TextPhoneTypeID = 0x1ccb966a

// construct implements constructor of RichTextClass.
func (t TextPhone) construct() RichTextClass { return &t }

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

	_ RichTextClass = &TextPhone{}
)

func (t *TextPhone) Zero() bool {
	if t == nil {
		return true
	}
	if !(t.Text == nil) {
		return false
	}
	if !(t.Phone == "") {
		return false
	}

	return true
}

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

// FillFrom fills TextPhone from given interface.
func (t *TextPhone) FillFrom(from interface {
	GetText() (value RichTextClass)
	GetPhone() (value string)
}) {
	t.Text = from.GetText()
	t.Phone = from.GetPhone()
}

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

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

// TypeInfo returns info about TL type.
func (t *TextPhone) TypeInfo() tdp.Type {
	typ := tdp.Type{
		Name: "textPhone",
		ID:   TextPhoneTypeID,
	}
	if t == nil {
		typ.Null = true
		return typ
	}
	typ.Fields = []tdp.Field{
		{
			Name:       "Text",
			SchemaName: "text",
		},
		{
			Name:       "Phone",
			SchemaName: "phone",
		},
	}
	return typ
}

// Encode implements bin.Encoder.
func (t *TextPhone) Encode(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't encode textPhone#1ccb966a as nil")
	}
	b.PutID(TextPhoneTypeID)
	return t.EncodeBare(b)
}

// EncodeBare implements bin.BareEncoder.
func (t *TextPhone) EncodeBare(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't encode textPhone#1ccb966a as nil")
	}
	if t.Text == nil {
		return fmt.Errorf("unable to encode textPhone#1ccb966a: field text is nil")
	}
	if err := t.Text.Encode(b); err != nil {
		return fmt.Errorf("unable to encode textPhone#1ccb966a: field text: %w", err)
	}
	b.PutString(t.Phone)
	return nil
}

// Decode implements bin.Decoder.
func (t *TextPhone) Decode(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't decode textPhone#1ccb966a to nil")
	}
	if err := b.ConsumeID(TextPhoneTypeID); err != nil {
		return fmt.Errorf("unable to decode textPhone#1ccb966a: %w", err)
	}
	return t.DecodeBare(b)
}

// DecodeBare implements bin.BareDecoder.
func (t *TextPhone) DecodeBare(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't decode textPhone#1ccb966a to nil")
	}
	{
		value, err := DecodeRichText(b)
		if err != nil {
			return fmt.Errorf("unable to decode textPhone#1ccb966a: field text: %w", err)
		}
		t.Text = value
	}
	{
		value, err := b.String()
		if err != nil {
			return fmt.Errorf("unable to decode textPhone#1ccb966a: field phone: %w", err)
		}
		t.Phone = value
	}
	return nil
}

// GetText returns value of Text field.
func (t *TextPhone) GetText() (value RichTextClass) {
	if t == nil {
		return
	}
	return t.Text
}

// GetPhone returns value of Phone field.
func (t *TextPhone) GetPhone() (value string) {
	if t == nil {
		return
	}
	return t.Phone
}

// TextImage represents TL type `textImage#81ccf4f`.
// Inline image
//
// See https://core.telegram.org/constructor/textImage for reference.
type TextImage struct {
	// Document ID
	DocumentID int64
	// Width
	W int
	// Height
	H int
}

// TextImageTypeID is TL type id of TextImage.
const TextImageTypeID = 0x81ccf4f

// construct implements constructor of RichTextClass.
func (t TextImage) construct() RichTextClass { return &t }

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

	_ RichTextClass = &TextImage{}
)

func (t *TextImage) Zero() bool {
	if t == nil {
		return true
	}
	if !(t.DocumentID == 0) {
		return false
	}
	if !(t.W == 0) {
		return false
	}
	if !(t.H == 0) {
		return false
	}

	return true
}

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

// FillFrom fills TextImage from given interface.
func (t *TextImage) FillFrom(from interface {
	GetDocumentID() (value int64)
	GetW() (value int)
	GetH() (value int)
}) {
	t.DocumentID = from.GetDocumentID()
	t.W = from.GetW()
	t.H = from.GetH()
}

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

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

// TypeInfo returns info about TL type.
func (t *TextImage) TypeInfo() tdp.Type {
	typ := tdp.Type{
		Name: "textImage",
		ID:   TextImageTypeID,
	}
	if t == nil {
		typ.Null = true
		return typ
	}
	typ.Fields = []tdp.Field{
		{
			Name:       "DocumentID",
			SchemaName: "document_id",
		},
		{
			Name:       "W",
			SchemaName: "w",
		},
		{
			Name:       "H",
			SchemaName: "h",
		},
	}
	return typ
}

// Encode implements bin.Encoder.
func (t *TextImage) Encode(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't encode textImage#81ccf4f as nil")
	}
	b.PutID(TextImageTypeID)
	return t.EncodeBare(b)
}

// EncodeBare implements bin.BareEncoder.
func (t *TextImage) EncodeBare(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't encode textImage#81ccf4f as nil")
	}
	b.PutLong(t.DocumentID)
	b.PutInt(t.W)
	b.PutInt(t.H)
	return nil
}

// Decode implements bin.Decoder.
func (t *TextImage) Decode(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't decode textImage#81ccf4f to nil")
	}
	if err := b.ConsumeID(TextImageTypeID); err != nil {
		return fmt.Errorf("unable to decode textImage#81ccf4f: %w", err)
	}
	return t.DecodeBare(b)
}

// DecodeBare implements bin.BareDecoder.
func (t *TextImage) DecodeBare(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't decode textImage#81ccf4f to nil")
	}
	{
		value, err := b.Long()
		if err != nil {
			return fmt.Errorf("unable to decode textImage#81ccf4f: field document_id: %w", err)
		}
		t.DocumentID = value
	}
	{
		value, err := b.Int()
		if err != nil {
			return fmt.Errorf("unable to decode textImage#81ccf4f: field w: %w", err)
		}
		t.W = value
	}
	{
		value, err := b.Int()
		if err != nil {
			return fmt.Errorf("unable to decode textImage#81ccf4f: field h: %w", err)
		}
		t.H = value
	}
	return nil
}

// GetDocumentID returns value of DocumentID field.
func (t *TextImage) GetDocumentID() (value int64) {
	if t == nil {
		return
	}
	return t.DocumentID
}

// GetW returns value of W field.
func (t *TextImage) GetW() (value int) {
	if t == nil {
		return
	}
	return t.W
}

// GetH returns value of H field.
func (t *TextImage) GetH() (value int) {
	if t == nil {
		return
	}
	return t.H
}

// TextAnchor represents TL type `textAnchor#35553762`.
// Text linking to another section of the page
//
// See https://core.telegram.org/constructor/textAnchor for reference.
type TextAnchor struct {
	// Text
	Text RichTextClass
	// Section name
	Name string
}

// TextAnchorTypeID is TL type id of TextAnchor.
const TextAnchorTypeID = 0x35553762

// construct implements constructor of RichTextClass.
func (t TextAnchor) construct() RichTextClass { return &t }

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

	_ RichTextClass = &TextAnchor{}
)

func (t *TextAnchor) Zero() bool {
	if t == nil {
		return true
	}
	if !(t.Text == nil) {
		return false
	}
	if !(t.Name == "") {
		return false
	}

	return true
}

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

// FillFrom fills TextAnchor from given interface.
func (t *TextAnchor) FillFrom(from interface {
	GetText() (value RichTextClass)
	GetName() (value string)
}) {
	t.Text = from.GetText()
	t.Name = from.GetName()
}

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

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

// TypeInfo returns info about TL type.
func (t *TextAnchor) TypeInfo() tdp.Type {
	typ := tdp.Type{
		Name: "textAnchor",
		ID:   TextAnchorTypeID,
	}
	if t == nil {
		typ.Null = true
		return typ
	}
	typ.Fields = []tdp.Field{
		{
			Name:       "Text",
			SchemaName: "text",
		},
		{
			Name:       "Name",
			SchemaName: "name",
		},
	}
	return typ
}

// Encode implements bin.Encoder.
func (t *TextAnchor) Encode(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't encode textAnchor#35553762 as nil")
	}
	b.PutID(TextAnchorTypeID)
	return t.EncodeBare(b)
}

// EncodeBare implements bin.BareEncoder.
func (t *TextAnchor) EncodeBare(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't encode textAnchor#35553762 as nil")
	}
	if t.Text == nil {
		return fmt.Errorf("unable to encode textAnchor#35553762: field text is nil")
	}
	if err := t.Text.Encode(b); err != nil {
		return fmt.Errorf("unable to encode textAnchor#35553762: field text: %w", err)
	}
	b.PutString(t.Name)
	return nil
}

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

// DecodeBare implements bin.BareDecoder.
func (t *TextAnchor) DecodeBare(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't decode textAnchor#35553762 to nil")
	}
	{
		value, err := DecodeRichText(b)
		if err != nil {
			return fmt.Errorf("unable to decode textAnchor#35553762: field text: %w", err)
		}
		t.Text = value
	}
	{
		value, err := b.String()
		if err != nil {
			return fmt.Errorf("unable to decode textAnchor#35553762: field name: %w", err)
		}
		t.Name = value
	}
	return nil
}

// GetText returns value of Text field.
func (t *TextAnchor) GetText() (value RichTextClass) {
	if t == nil {
		return
	}
	return t.Text
}

// GetName returns value of Name field.
func (t *TextAnchor) GetName() (value string) {
	if t == nil {
		return
	}
	return t.Name
}

// TextMath represents TL type `textMath#9d2eac97`.
//
// See https://core.telegram.org/constructor/textMath for reference.
type TextMath struct {
	// Source field of TextMath.
	Source string
}

// TextMathTypeID is TL type id of TextMath.
const TextMathTypeID = 0x9d2eac97

// construct implements constructor of RichTextClass.
func (t TextMath) construct() RichTextClass { return &t }

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

	_ RichTextClass = &TextMath{}
)

func (t *TextMath) Zero() bool {
	if t == nil {
		return true
	}
	if !(t.Source == "") {
		return false
	}

	return true
}

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

// FillFrom fills TextMath from given interface.
func (t *TextMath) FillFrom(from interface {
	GetSource() (value string)
}) {
	t.Source = from.GetSource()
}

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

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

// TypeInfo returns info about TL type.
func (t *TextMath) TypeInfo() tdp.Type {
	typ := tdp.Type{
		Name: "textMath",
		ID:   TextMathTypeID,
	}
	if t == nil {
		typ.Null = true
		return typ
	}
	typ.Fields = []tdp.Field{
		{
			Name:       "Source",
			SchemaName: "source",
		},
	}
	return typ
}

// Encode implements bin.Encoder.
func (t *TextMath) Encode(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't encode textMath#9d2eac97 as nil")
	}
	b.PutID(TextMathTypeID)
	return t.EncodeBare(b)
}

// EncodeBare implements bin.BareEncoder.
func (t *TextMath) EncodeBare(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't encode textMath#9d2eac97 as nil")
	}
	b.PutString(t.Source)
	return nil
}

// Decode implements bin.Decoder.
func (t *TextMath) Decode(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't decode textMath#9d2eac97 to nil")
	}
	if err := b.ConsumeID(TextMathTypeID); err != nil {
		return fmt.Errorf("unable to decode textMath#9d2eac97: %w", err)
	}
	return t.DecodeBare(b)
}

// DecodeBare implements bin.BareDecoder.
func (t *TextMath) DecodeBare(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't decode textMath#9d2eac97 to nil")
	}
	{
		value, err := b.String()
		if err != nil {
			return fmt.Errorf("unable to decode textMath#9d2eac97: field source: %w", err)
		}
		t.Source = value
	}
	return nil
}

// GetSource returns value of Source field.
func (t *TextMath) GetSource() (value string) {
	if t == nil {
		return
	}
	return t.Source
}

// TextCustomEmoji represents TL type `textCustomEmoji#a26156c0`.
//
// See https://core.telegram.org/constructor/textCustomEmoji for reference.
type TextCustomEmoji struct {
	// DocumentID field of TextCustomEmoji.
	DocumentID int64
	// Alt field of TextCustomEmoji.
	Alt string
}

// TextCustomEmojiTypeID is TL type id of TextCustomEmoji.
const TextCustomEmojiTypeID = 0xa26156c0

// construct implements constructor of RichTextClass.
func (t TextCustomEmoji) construct() RichTextClass { return &t }

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

	_ RichTextClass = &TextCustomEmoji{}
)

func (t *TextCustomEmoji) Zero() bool {
	if t == nil {
		return true
	}
	if !(t.DocumentID == 0) {
		return false
	}
	if !(t.Alt == "") {
		return false
	}

	return true
}

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

// FillFrom fills TextCustomEmoji from given interface.
func (t *TextCustomEmoji) FillFrom(from interface {
	GetDocumentID() (value int64)
	GetAlt() (value string)
}) {
	t.DocumentID = from.GetDocumentID()
	t.Alt = from.GetAlt()
}

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

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

// TypeInfo returns info about TL type.
func (t *TextCustomEmoji) TypeInfo() tdp.Type {
	typ := tdp.Type{
		Name: "textCustomEmoji",
		ID:   TextCustomEmojiTypeID,
	}
	if t == nil {
		typ.Null = true
		return typ
	}
	typ.Fields = []tdp.Field{
		{
			Name:       "DocumentID",
			SchemaName: "document_id",
		},
		{
			Name:       "Alt",
			SchemaName: "alt",
		},
	}
	return typ
}

// Encode implements bin.Encoder.
func (t *TextCustomEmoji) Encode(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't encode textCustomEmoji#a26156c0 as nil")
	}
	b.PutID(TextCustomEmojiTypeID)
	return t.EncodeBare(b)
}

// EncodeBare implements bin.BareEncoder.
func (t *TextCustomEmoji) EncodeBare(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't encode textCustomEmoji#a26156c0 as nil")
	}
	b.PutLong(t.DocumentID)
	b.PutString(t.Alt)
	return nil
}

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

// DecodeBare implements bin.BareDecoder.
func (t *TextCustomEmoji) DecodeBare(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't decode textCustomEmoji#a26156c0 to nil")
	}
	{
		value, err := b.Long()
		if err != nil {
			return fmt.Errorf("unable to decode textCustomEmoji#a26156c0: field document_id: %w", err)
		}
		t.DocumentID = value
	}
	{
		value, err := b.String()
		if err != nil {
			return fmt.Errorf("unable to decode textCustomEmoji#a26156c0: field alt: %w", err)
		}
		t.Alt = value
	}
	return nil
}

// GetDocumentID returns value of DocumentID field.
func (t *TextCustomEmoji) GetDocumentID() (value int64) {
	if t == nil {
		return
	}
	return t.DocumentID
}

// GetAlt returns value of Alt field.
func (t *TextCustomEmoji) GetAlt() (value string) {
	if t == nil {
		return
	}
	return t.Alt
}

// TextSpoiler represents TL type `textSpoiler#4c2a5d62`.
//
// See https://core.telegram.org/constructor/textSpoiler for reference.
type TextSpoiler struct {
	// Text field of TextSpoiler.
	Text RichTextClass
}

// TextSpoilerTypeID is TL type id of TextSpoiler.
const TextSpoilerTypeID = 0x4c2a5d62

// construct implements constructor of RichTextClass.
func (t TextSpoiler) construct() RichTextClass { return &t }

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

	_ RichTextClass = &TextSpoiler{}
)

func (t *TextSpoiler) Zero() bool {
	if t == nil {
		return true
	}
	if !(t.Text == nil) {
		return false
	}

	return true
}

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

// FillFrom fills TextSpoiler from given interface.
func (t *TextSpoiler) FillFrom(from interface {
	GetText() (value RichTextClass)
}) {
	t.Text = from.GetText()
}

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

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

// TypeInfo returns info about TL type.
func (t *TextSpoiler) TypeInfo() tdp.Type {
	typ := tdp.Type{
		Name: "textSpoiler",
		ID:   TextSpoilerTypeID,
	}
	if t == nil {
		typ.Null = true
		return typ
	}
	typ.Fields = []tdp.Field{
		{
			Name:       "Text",
			SchemaName: "text",
		},
	}
	return typ
}

// Encode implements bin.Encoder.
func (t *TextSpoiler) Encode(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't encode textSpoiler#4c2a5d62 as nil")
	}
	b.PutID(TextSpoilerTypeID)
	return t.EncodeBare(b)
}

// EncodeBare implements bin.BareEncoder.
func (t *TextSpoiler) EncodeBare(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't encode textSpoiler#4c2a5d62 as nil")
	}
	if t.Text == nil {
		return fmt.Errorf("unable to encode textSpoiler#4c2a5d62: field text is nil")
	}
	if err := t.Text.Encode(b); err != nil {
		return fmt.Errorf("unable to encode textSpoiler#4c2a5d62: field text: %w", err)
	}
	return nil
}

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

// DecodeBare implements bin.BareDecoder.
func (t *TextSpoiler) DecodeBare(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't decode textSpoiler#4c2a5d62 to nil")
	}
	{
		value, err := DecodeRichText(b)
		if err != nil {
			return fmt.Errorf("unable to decode textSpoiler#4c2a5d62: field text: %w", err)
		}
		t.Text = value
	}
	return nil
}

// GetText returns value of Text field.
func (t *TextSpoiler) GetText() (value RichTextClass) {
	if t == nil {
		return
	}
	return t.Text
}

// TextMention represents TL type `textMention#cd24cf44`.
//
// See https://core.telegram.org/constructor/textMention for reference.
type TextMention struct {
	// Text field of TextMention.
	Text RichTextClass
}

// TextMentionTypeID is TL type id of TextMention.
const TextMentionTypeID = 0xcd24cf44

// construct implements constructor of RichTextClass.
func (t TextMention) construct() RichTextClass { return &t }

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

	_ RichTextClass = &TextMention{}
)

func (t *TextMention) Zero() bool {
	if t == nil {
		return true
	}
	if !(t.Text == nil) {
		return false
	}

	return true
}

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

// FillFrom fills TextMention from given interface.
func (t *TextMention) FillFrom(from interface {
	GetText() (value RichTextClass)
}) {
	t.Text = from.GetText()
}

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

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

// TypeInfo returns info about TL type.
func (t *TextMention) TypeInfo() tdp.Type {
	typ := tdp.Type{
		Name: "textMention",
		ID:   TextMentionTypeID,
	}
	if t == nil {
		typ.Null = true
		return typ
	}
	typ.Fields = []tdp.Field{
		{
			Name:       "Text",
			SchemaName: "text",
		},
	}
	return typ
}

// Encode implements bin.Encoder.
func (t *TextMention) Encode(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't encode textMention#cd24cf44 as nil")
	}
	b.PutID(TextMentionTypeID)
	return t.EncodeBare(b)
}

// EncodeBare implements bin.BareEncoder.
func (t *TextMention) EncodeBare(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't encode textMention#cd24cf44 as nil")
	}
	if t.Text == nil {
		return fmt.Errorf("unable to encode textMention#cd24cf44: field text is nil")
	}
	if err := t.Text.Encode(b); err != nil {
		return fmt.Errorf("unable to encode textMention#cd24cf44: field text: %w", err)
	}
	return nil
}

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

// DecodeBare implements bin.BareDecoder.
func (t *TextMention) DecodeBare(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't decode textMention#cd24cf44 to nil")
	}
	{
		value, err := DecodeRichText(b)
		if err != nil {
			return fmt.Errorf("unable to decode textMention#cd24cf44: field text: %w", err)
		}
		t.Text = value
	}
	return nil
}

// GetText returns value of Text field.
func (t *TextMention) GetText() (value RichTextClass) {
	if t == nil {
		return
	}
	return t.Text
}

// TextHashtag represents TL type `textHashtag#519524ea`.
//
// See https://core.telegram.org/constructor/textHashtag for reference.
type TextHashtag struct {
	// Text field of TextHashtag.
	Text RichTextClass
}

// TextHashtagTypeID is TL type id of TextHashtag.
const TextHashtagTypeID = 0x519524ea

// construct implements constructor of RichTextClass.
func (t TextHashtag) construct() RichTextClass { return &t }

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

	_ RichTextClass = &TextHashtag{}
)

func (t *TextHashtag) Zero() bool {
	if t == nil {
		return true
	}
	if !(t.Text == nil) {
		return false
	}

	return true
}

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

// FillFrom fills TextHashtag from given interface.
func (t *TextHashtag) FillFrom(from interface {
	GetText() (value RichTextClass)
}) {
	t.Text = from.GetText()
}

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

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

// TypeInfo returns info about TL type.
func (t *TextHashtag) TypeInfo() tdp.Type {
	typ := tdp.Type{
		Name: "textHashtag",
		ID:   TextHashtagTypeID,
	}
	if t == nil {
		typ.Null = true
		return typ
	}
	typ.Fields = []tdp.Field{
		{
			Name:       "Text",
			SchemaName: "text",
		},
	}
	return typ
}

// Encode implements bin.Encoder.
func (t *TextHashtag) Encode(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't encode textHashtag#519524ea as nil")
	}
	b.PutID(TextHashtagTypeID)
	return t.EncodeBare(b)
}

// EncodeBare implements bin.BareEncoder.
func (t *TextHashtag) EncodeBare(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't encode textHashtag#519524ea as nil")
	}
	if t.Text == nil {
		return fmt.Errorf("unable to encode textHashtag#519524ea: field text is nil")
	}
	if err := t.Text.Encode(b); err != nil {
		return fmt.Errorf("unable to encode textHashtag#519524ea: field text: %w", err)
	}
	return nil
}

// Decode implements bin.Decoder.
func (t *TextHashtag) Decode(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't decode textHashtag#519524ea to nil")
	}
	if err := b.ConsumeID(TextHashtagTypeID); err != nil {
		return fmt.Errorf("unable to decode textHashtag#519524ea: %w", err)
	}
	return t.DecodeBare(b)
}

// DecodeBare implements bin.BareDecoder.
func (t *TextHashtag) DecodeBare(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't decode textHashtag#519524ea to nil")
	}
	{
		value, err := DecodeRichText(b)
		if err != nil {
			return fmt.Errorf("unable to decode textHashtag#519524ea: field text: %w", err)
		}
		t.Text = value
	}
	return nil
}

// GetText returns value of Text field.
func (t *TextHashtag) GetText() (value RichTextClass) {
	if t == nil {
		return
	}
	return t.Text
}

// TextBotCommand represents TL type `textBotCommand#2ff29d3`.
//
// See https://core.telegram.org/constructor/textBotCommand for reference.
type TextBotCommand struct {
	// Text field of TextBotCommand.
	Text RichTextClass
}

// TextBotCommandTypeID is TL type id of TextBotCommand.
const TextBotCommandTypeID = 0x2ff29d3

// construct implements constructor of RichTextClass.
func (t TextBotCommand) construct() RichTextClass { return &t }

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

	_ RichTextClass = &TextBotCommand{}
)

func (t *TextBotCommand) Zero() bool {
	if t == nil {
		return true
	}
	if !(t.Text == nil) {
		return false
	}

	return true
}

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

// FillFrom fills TextBotCommand from given interface.
func (t *TextBotCommand) FillFrom(from interface {
	GetText() (value RichTextClass)
}) {
	t.Text = from.GetText()
}

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

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

// TypeInfo returns info about TL type.
func (t *TextBotCommand) TypeInfo() tdp.Type {
	typ := tdp.Type{
		Name: "textBotCommand",
		ID:   TextBotCommandTypeID,
	}
	if t == nil {
		typ.Null = true
		return typ
	}
	typ.Fields = []tdp.Field{
		{
			Name:       "Text",
			SchemaName: "text",
		},
	}
	return typ
}

// Encode implements bin.Encoder.
func (t *TextBotCommand) Encode(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't encode textBotCommand#2ff29d3 as nil")
	}
	b.PutID(TextBotCommandTypeID)
	return t.EncodeBare(b)
}

// EncodeBare implements bin.BareEncoder.
func (t *TextBotCommand) EncodeBare(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't encode textBotCommand#2ff29d3 as nil")
	}
	if t.Text == nil {
		return fmt.Errorf("unable to encode textBotCommand#2ff29d3: field text is nil")
	}
	if err := t.Text.Encode(b); err != nil {
		return fmt.Errorf("unable to encode textBotCommand#2ff29d3: field text: %w", err)
	}
	return nil
}

// Decode implements bin.Decoder.
func (t *TextBotCommand) Decode(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't decode textBotCommand#2ff29d3 to nil")
	}
	if err := b.ConsumeID(TextBotCommandTypeID); err != nil {
		return fmt.Errorf("unable to decode textBotCommand#2ff29d3: %w", err)
	}
	return t.DecodeBare(b)
}

// DecodeBare implements bin.BareDecoder.
func (t *TextBotCommand) DecodeBare(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't decode textBotCommand#2ff29d3 to nil")
	}
	{
		value, err := DecodeRichText(b)
		if err != nil {
			return fmt.Errorf("unable to decode textBotCommand#2ff29d3: field text: %w", err)
		}
		t.Text = value
	}
	return nil
}

// GetText returns value of Text field.
func (t *TextBotCommand) GetText() (value RichTextClass) {
	if t == nil {
		return
	}
	return t.Text
}

// TextCashtag represents TL type `textCashtag#7b9e1801`.
//
// See https://core.telegram.org/constructor/textCashtag for reference.
type TextCashtag struct {
	// Text field of TextCashtag.
	Text RichTextClass
}

// TextCashtagTypeID is TL type id of TextCashtag.
const TextCashtagTypeID = 0x7b9e1801

// construct implements constructor of RichTextClass.
func (t TextCashtag) construct() RichTextClass { return &t }

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

	_ RichTextClass = &TextCashtag{}
)

func (t *TextCashtag) Zero() bool {
	if t == nil {
		return true
	}
	if !(t.Text == nil) {
		return false
	}

	return true
}

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

// FillFrom fills TextCashtag from given interface.
func (t *TextCashtag) FillFrom(from interface {
	GetText() (value RichTextClass)
}) {
	t.Text = from.GetText()
}

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

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

// TypeInfo returns info about TL type.
func (t *TextCashtag) TypeInfo() tdp.Type {
	typ := tdp.Type{
		Name: "textCashtag",
		ID:   TextCashtagTypeID,
	}
	if t == nil {
		typ.Null = true
		return typ
	}
	typ.Fields = []tdp.Field{
		{
			Name:       "Text",
			SchemaName: "text",
		},
	}
	return typ
}

// Encode implements bin.Encoder.
func (t *TextCashtag) Encode(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't encode textCashtag#7b9e1801 as nil")
	}
	b.PutID(TextCashtagTypeID)
	return t.EncodeBare(b)
}

// EncodeBare implements bin.BareEncoder.
func (t *TextCashtag) EncodeBare(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't encode textCashtag#7b9e1801 as nil")
	}
	if t.Text == nil {
		return fmt.Errorf("unable to encode textCashtag#7b9e1801: field text is nil")
	}
	if err := t.Text.Encode(b); err != nil {
		return fmt.Errorf("unable to encode textCashtag#7b9e1801: field text: %w", err)
	}
	return nil
}

// Decode implements bin.Decoder.
func (t *TextCashtag) Decode(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't decode textCashtag#7b9e1801 to nil")
	}
	if err := b.ConsumeID(TextCashtagTypeID); err != nil {
		return fmt.Errorf("unable to decode textCashtag#7b9e1801: %w", err)
	}
	return t.DecodeBare(b)
}

// DecodeBare implements bin.BareDecoder.
func (t *TextCashtag) DecodeBare(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't decode textCashtag#7b9e1801 to nil")
	}
	{
		value, err := DecodeRichText(b)
		if err != nil {
			return fmt.Errorf("unable to decode textCashtag#7b9e1801: field text: %w", err)
		}
		t.Text = value
	}
	return nil
}

// GetText returns value of Text field.
func (t *TextCashtag) GetText() (value RichTextClass) {
	if t == nil {
		return
	}
	return t.Text
}

// TextAutoURL represents TL type `textAutoUrl#ac6a83aa`.
//
// See https://core.telegram.org/constructor/textAutoUrl for reference.
type TextAutoURL struct {
	// Text field of TextAutoURL.
	Text RichTextClass
}

// TextAutoURLTypeID is TL type id of TextAutoURL.
const TextAutoURLTypeID = 0xac6a83aa

// construct implements constructor of RichTextClass.
func (t TextAutoURL) construct() RichTextClass { return &t }

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

	_ RichTextClass = &TextAutoURL{}
)

func (t *TextAutoURL) Zero() bool {
	if t == nil {
		return true
	}
	if !(t.Text == nil) {
		return false
	}

	return true
}

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

// FillFrom fills TextAutoURL from given interface.
func (t *TextAutoURL) FillFrom(from interface {
	GetText() (value RichTextClass)
}) {
	t.Text = from.GetText()
}

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

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

// TypeInfo returns info about TL type.
func (t *TextAutoURL) TypeInfo() tdp.Type {
	typ := tdp.Type{
		Name: "textAutoUrl",
		ID:   TextAutoURLTypeID,
	}
	if t == nil {
		typ.Null = true
		return typ
	}
	typ.Fields = []tdp.Field{
		{
			Name:       "Text",
			SchemaName: "text",
		},
	}
	return typ
}

// Encode implements bin.Encoder.
func (t *TextAutoURL) Encode(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't encode textAutoUrl#ac6a83aa as nil")
	}
	b.PutID(TextAutoURLTypeID)
	return t.EncodeBare(b)
}

// EncodeBare implements bin.BareEncoder.
func (t *TextAutoURL) EncodeBare(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't encode textAutoUrl#ac6a83aa as nil")
	}
	if t.Text == nil {
		return fmt.Errorf("unable to encode textAutoUrl#ac6a83aa: field text is nil")
	}
	if err := t.Text.Encode(b); err != nil {
		return fmt.Errorf("unable to encode textAutoUrl#ac6a83aa: field text: %w", err)
	}
	return nil
}

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

// DecodeBare implements bin.BareDecoder.
func (t *TextAutoURL) DecodeBare(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't decode textAutoUrl#ac6a83aa to nil")
	}
	{
		value, err := DecodeRichText(b)
		if err != nil {
			return fmt.Errorf("unable to decode textAutoUrl#ac6a83aa: field text: %w", err)
		}
		t.Text = value
	}
	return nil
}

// GetText returns value of Text field.
func (t *TextAutoURL) GetText() (value RichTextClass) {
	if t == nil {
		return
	}
	return t.Text
}

// TextAutoEmail represents TL type `textAutoEmail#c556a45d`.
//
// See https://core.telegram.org/constructor/textAutoEmail for reference.
type TextAutoEmail struct {
	// Text field of TextAutoEmail.
	Text RichTextClass
}

// TextAutoEmailTypeID is TL type id of TextAutoEmail.
const TextAutoEmailTypeID = 0xc556a45d

// construct implements constructor of RichTextClass.
func (t TextAutoEmail) construct() RichTextClass { return &t }

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

	_ RichTextClass = &TextAutoEmail{}
)

func (t *TextAutoEmail) Zero() bool {
	if t == nil {
		return true
	}
	if !(t.Text == nil) {
		return false
	}

	return true
}

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

// FillFrom fills TextAutoEmail from given interface.
func (t *TextAutoEmail) FillFrom(from interface {
	GetText() (value RichTextClass)
}) {
	t.Text = from.GetText()
}

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

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

// TypeInfo returns info about TL type.
func (t *TextAutoEmail) TypeInfo() tdp.Type {
	typ := tdp.Type{
		Name: "textAutoEmail",
		ID:   TextAutoEmailTypeID,
	}
	if t == nil {
		typ.Null = true
		return typ
	}
	typ.Fields = []tdp.Field{
		{
			Name:       "Text",
			SchemaName: "text",
		},
	}
	return typ
}

// Encode implements bin.Encoder.
func (t *TextAutoEmail) Encode(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't encode textAutoEmail#c556a45d as nil")
	}
	b.PutID(TextAutoEmailTypeID)
	return t.EncodeBare(b)
}

// EncodeBare implements bin.BareEncoder.
func (t *TextAutoEmail) EncodeBare(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't encode textAutoEmail#c556a45d as nil")
	}
	if t.Text == nil {
		return fmt.Errorf("unable to encode textAutoEmail#c556a45d: field text is nil")
	}
	if err := t.Text.Encode(b); err != nil {
		return fmt.Errorf("unable to encode textAutoEmail#c556a45d: field text: %w", err)
	}
	return nil
}

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

// DecodeBare implements bin.BareDecoder.
func (t *TextAutoEmail) DecodeBare(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't decode textAutoEmail#c556a45d to nil")
	}
	{
		value, err := DecodeRichText(b)
		if err != nil {
			return fmt.Errorf("unable to decode textAutoEmail#c556a45d: field text: %w", err)
		}
		t.Text = value
	}
	return nil
}

// GetText returns value of Text field.
func (t *TextAutoEmail) GetText() (value RichTextClass) {
	if t == nil {
		return
	}
	return t.Text
}

// TextAutoPhone represents TL type `textAutoPhone#24c26789`.
//
// See https://core.telegram.org/constructor/textAutoPhone for reference.
type TextAutoPhone struct {
	// Text field of TextAutoPhone.
	Text RichTextClass
}

// TextAutoPhoneTypeID is TL type id of TextAutoPhone.
const TextAutoPhoneTypeID = 0x24c26789

// construct implements constructor of RichTextClass.
func (t TextAutoPhone) construct() RichTextClass { return &t }

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

	_ RichTextClass = &TextAutoPhone{}
)

func (t *TextAutoPhone) Zero() bool {
	if t == nil {
		return true
	}
	if !(t.Text == nil) {
		return false
	}

	return true
}

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

// FillFrom fills TextAutoPhone from given interface.
func (t *TextAutoPhone) FillFrom(from interface {
	GetText() (value RichTextClass)
}) {
	t.Text = from.GetText()
}

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

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

// TypeInfo returns info about TL type.
func (t *TextAutoPhone) TypeInfo() tdp.Type {
	typ := tdp.Type{
		Name: "textAutoPhone",
		ID:   TextAutoPhoneTypeID,
	}
	if t == nil {
		typ.Null = true
		return typ
	}
	typ.Fields = []tdp.Field{
		{
			Name:       "Text",
			SchemaName: "text",
		},
	}
	return typ
}

// Encode implements bin.Encoder.
func (t *TextAutoPhone) Encode(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't encode textAutoPhone#24c26789 as nil")
	}
	b.PutID(TextAutoPhoneTypeID)
	return t.EncodeBare(b)
}

// EncodeBare implements bin.BareEncoder.
func (t *TextAutoPhone) EncodeBare(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't encode textAutoPhone#24c26789 as nil")
	}
	if t.Text == nil {
		return fmt.Errorf("unable to encode textAutoPhone#24c26789: field text is nil")
	}
	if err := t.Text.Encode(b); err != nil {
		return fmt.Errorf("unable to encode textAutoPhone#24c26789: field text: %w", err)
	}
	return nil
}

// Decode implements bin.Decoder.
func (t *TextAutoPhone) Decode(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't decode textAutoPhone#24c26789 to nil")
	}
	if err := b.ConsumeID(TextAutoPhoneTypeID); err != nil {
		return fmt.Errorf("unable to decode textAutoPhone#24c26789: %w", err)
	}
	return t.DecodeBare(b)
}

// DecodeBare implements bin.BareDecoder.
func (t *TextAutoPhone) DecodeBare(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't decode textAutoPhone#24c26789 to nil")
	}
	{
		value, err := DecodeRichText(b)
		if err != nil {
			return fmt.Errorf("unable to decode textAutoPhone#24c26789: field text: %w", err)
		}
		t.Text = value
	}
	return nil
}

// GetText returns value of Text field.
func (t *TextAutoPhone) GetText() (value RichTextClass) {
	if t == nil {
		return
	}
	return t.Text
}

// TextBankCard represents TL type `textBankCard#b956812d`.
//
// See https://core.telegram.org/constructor/textBankCard for reference.
type TextBankCard struct {
	// Text field of TextBankCard.
	Text RichTextClass
}

// TextBankCardTypeID is TL type id of TextBankCard.
const TextBankCardTypeID = 0xb956812d

// construct implements constructor of RichTextClass.
func (t TextBankCard) construct() RichTextClass { return &t }

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

	_ RichTextClass = &TextBankCard{}
)

func (t *TextBankCard) Zero() bool {
	if t == nil {
		return true
	}
	if !(t.Text == nil) {
		return false
	}

	return true
}

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

// FillFrom fills TextBankCard from given interface.
func (t *TextBankCard) FillFrom(from interface {
	GetText() (value RichTextClass)
}) {
	t.Text = from.GetText()
}

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

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

// TypeInfo returns info about TL type.
func (t *TextBankCard) TypeInfo() tdp.Type {
	typ := tdp.Type{
		Name: "textBankCard",
		ID:   TextBankCardTypeID,
	}
	if t == nil {
		typ.Null = true
		return typ
	}
	typ.Fields = []tdp.Field{
		{
			Name:       "Text",
			SchemaName: "text",
		},
	}
	return typ
}

// Encode implements bin.Encoder.
func (t *TextBankCard) Encode(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't encode textBankCard#b956812d as nil")
	}
	b.PutID(TextBankCardTypeID)
	return t.EncodeBare(b)
}

// EncodeBare implements bin.BareEncoder.
func (t *TextBankCard) EncodeBare(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't encode textBankCard#b956812d as nil")
	}
	if t.Text == nil {
		return fmt.Errorf("unable to encode textBankCard#b956812d: field text is nil")
	}
	if err := t.Text.Encode(b); err != nil {
		return fmt.Errorf("unable to encode textBankCard#b956812d: field text: %w", err)
	}
	return nil
}

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

// DecodeBare implements bin.BareDecoder.
func (t *TextBankCard) DecodeBare(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't decode textBankCard#b956812d to nil")
	}
	{
		value, err := DecodeRichText(b)
		if err != nil {
			return fmt.Errorf("unable to decode textBankCard#b956812d: field text: %w", err)
		}
		t.Text = value
	}
	return nil
}

// GetText returns value of Text field.
func (t *TextBankCard) GetText() (value RichTextClass) {
	if t == nil {
		return
	}
	return t.Text
}

// TextMentionName represents TL type `textMentionName#1a9fbfc`.
//
// See https://core.telegram.org/constructor/textMentionName for reference.
type TextMentionName struct {
	// Text field of TextMentionName.
	Text RichTextClass
	// UserID field of TextMentionName.
	UserID int64
}

// TextMentionNameTypeID is TL type id of TextMentionName.
const TextMentionNameTypeID = 0x1a9fbfc

// construct implements constructor of RichTextClass.
func (t TextMentionName) construct() RichTextClass { return &t }

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

	_ RichTextClass = &TextMentionName{}
)

func (t *TextMentionName) Zero() bool {
	if t == nil {
		return true
	}
	if !(t.Text == nil) {
		return false
	}
	if !(t.UserID == 0) {
		return false
	}

	return true
}

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

// FillFrom fills TextMentionName from given interface.
func (t *TextMentionName) FillFrom(from interface {
	GetText() (value RichTextClass)
	GetUserID() (value int64)
}) {
	t.Text = from.GetText()
	t.UserID = from.GetUserID()
}

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

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

// TypeInfo returns info about TL type.
func (t *TextMentionName) TypeInfo() tdp.Type {
	typ := tdp.Type{
		Name: "textMentionName",
		ID:   TextMentionNameTypeID,
	}
	if t == nil {
		typ.Null = true
		return typ
	}
	typ.Fields = []tdp.Field{
		{
			Name:       "Text",
			SchemaName: "text",
		},
		{
			Name:       "UserID",
			SchemaName: "user_id",
		},
	}
	return typ
}

// Encode implements bin.Encoder.
func (t *TextMentionName) Encode(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't encode textMentionName#1a9fbfc as nil")
	}
	b.PutID(TextMentionNameTypeID)
	return t.EncodeBare(b)
}

// EncodeBare implements bin.BareEncoder.
func (t *TextMentionName) EncodeBare(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't encode textMentionName#1a9fbfc as nil")
	}
	if t.Text == nil {
		return fmt.Errorf("unable to encode textMentionName#1a9fbfc: field text is nil")
	}
	if err := t.Text.Encode(b); err != nil {
		return fmt.Errorf("unable to encode textMentionName#1a9fbfc: field text: %w", err)
	}
	b.PutLong(t.UserID)
	return nil
}

// Decode implements bin.Decoder.
func (t *TextMentionName) Decode(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't decode textMentionName#1a9fbfc to nil")
	}
	if err := b.ConsumeID(TextMentionNameTypeID); err != nil {
		return fmt.Errorf("unable to decode textMentionName#1a9fbfc: %w", err)
	}
	return t.DecodeBare(b)
}

// DecodeBare implements bin.BareDecoder.
func (t *TextMentionName) DecodeBare(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't decode textMentionName#1a9fbfc to nil")
	}
	{
		value, err := DecodeRichText(b)
		if err != nil {
			return fmt.Errorf("unable to decode textMentionName#1a9fbfc: field text: %w", err)
		}
		t.Text = value
	}
	{
		value, err := b.Long()
		if err != nil {
			return fmt.Errorf("unable to decode textMentionName#1a9fbfc: field user_id: %w", err)
		}
		t.UserID = value
	}
	return nil
}

// GetText returns value of Text field.
func (t *TextMentionName) GetText() (value RichTextClass) {
	if t == nil {
		return
	}
	return t.Text
}

// GetUserID returns value of UserID field.
func (t *TextMentionName) GetUserID() (value int64) {
	if t == nil {
		return
	}
	return t.UserID
}

// TextDate represents TL type `textDate#a5b45e2b`.
//
// See https://core.telegram.org/constructor/textDate for reference.
type TextDate struct {
	// Flags field of TextDate.
	Flags bin.Fields
	// Relative field of TextDate.
	Relative bool
	// ShortTime field of TextDate.
	ShortTime bool
	// LongTime field of TextDate.
	LongTime bool
	// ShortDate field of TextDate.
	ShortDate bool
	// LongDate field of TextDate.
	LongDate bool
	// DayOfWeek field of TextDate.
	DayOfWeek bool
	// Text field of TextDate.
	Text RichTextClass
	// Date field of TextDate.
	Date int
}

// TextDateTypeID is TL type id of TextDate.
const TextDateTypeID = 0xa5b45e2b

// construct implements constructor of RichTextClass.
func (t TextDate) construct() RichTextClass { return &t }

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

	_ RichTextClass = &TextDate{}
)

func (t *TextDate) Zero() bool {
	if t == nil {
		return true
	}
	if !(t.Flags.Zero()) {
		return false
	}
	if !(t.Relative == false) {
		return false
	}
	if !(t.ShortTime == false) {
		return false
	}
	if !(t.LongTime == false) {
		return false
	}
	if !(t.ShortDate == false) {
		return false
	}
	if !(t.LongDate == false) {
		return false
	}
	if !(t.DayOfWeek == false) {
		return false
	}
	if !(t.Text == nil) {
		return false
	}
	if !(t.Date == 0) {
		return false
	}

	return true
}

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

// FillFrom fills TextDate from given interface.
func (t *TextDate) FillFrom(from interface {
	GetRelative() (value bool)
	GetShortTime() (value bool)
	GetLongTime() (value bool)
	GetShortDate() (value bool)
	GetLongDate() (value bool)
	GetDayOfWeek() (value bool)
	GetText() (value RichTextClass)
	GetDate() (value int)
}) {
	t.Relative = from.GetRelative()
	t.ShortTime = from.GetShortTime()
	t.LongTime = from.GetLongTime()
	t.ShortDate = from.GetShortDate()
	t.LongDate = from.GetLongDate()
	t.DayOfWeek = from.GetDayOfWeek()
	t.Text = from.GetText()
	t.Date = from.GetDate()
}

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

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

// TypeInfo returns info about TL type.
func (t *TextDate) TypeInfo() tdp.Type {
	typ := tdp.Type{
		Name: "textDate",
		ID:   TextDateTypeID,
	}
	if t == nil {
		typ.Null = true
		return typ
	}
	typ.Fields = []tdp.Field{
		{
			Name:       "Relative",
			SchemaName: "relative",
			Null:       !t.Flags.Has(0),
		},
		{
			Name:       "ShortTime",
			SchemaName: "short_time",
			Null:       !t.Flags.Has(1),
		},
		{
			Name:       "LongTime",
			SchemaName: "long_time",
			Null:       !t.Flags.Has(2),
		},
		{
			Name:       "ShortDate",
			SchemaName: "short_date",
			Null:       !t.Flags.Has(3),
		},
		{
			Name:       "LongDate",
			SchemaName: "long_date",
			Null:       !t.Flags.Has(4),
		},
		{
			Name:       "DayOfWeek",
			SchemaName: "day_of_week",
			Null:       !t.Flags.Has(5),
		},
		{
			Name:       "Text",
			SchemaName: "text",
		},
		{
			Name:       "Date",
			SchemaName: "date",
		},
	}
	return typ
}

// SetFlags sets flags for non-zero fields.
func (t *TextDate) SetFlags() {
	if !(t.Relative == false) {
		t.Flags.Set(0)
	}
	if !(t.ShortTime == false) {
		t.Flags.Set(1)
	}
	if !(t.LongTime == false) {
		t.Flags.Set(2)
	}
	if !(t.ShortDate == false) {
		t.Flags.Set(3)
	}
	if !(t.LongDate == false) {
		t.Flags.Set(4)
	}
	if !(t.DayOfWeek == false) {
		t.Flags.Set(5)
	}
}

// Encode implements bin.Encoder.
func (t *TextDate) Encode(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't encode textDate#a5b45e2b as nil")
	}
	b.PutID(TextDateTypeID)
	return t.EncodeBare(b)
}

// EncodeBare implements bin.BareEncoder.
func (t *TextDate) EncodeBare(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't encode textDate#a5b45e2b as nil")
	}
	t.SetFlags()
	if err := t.Flags.Encode(b); err != nil {
		return fmt.Errorf("unable to encode textDate#a5b45e2b: field flags: %w", err)
	}
	if t.Text == nil {
		return fmt.Errorf("unable to encode textDate#a5b45e2b: field text is nil")
	}
	if err := t.Text.Encode(b); err != nil {
		return fmt.Errorf("unable to encode textDate#a5b45e2b: field text: %w", err)
	}
	b.PutInt(t.Date)
	return nil
}

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

// DecodeBare implements bin.BareDecoder.
func (t *TextDate) DecodeBare(b *bin.Buffer) error {
	if t == nil {
		return fmt.Errorf("can't decode textDate#a5b45e2b to nil")
	}
	{
		if err := t.Flags.Decode(b); err != nil {
			return fmt.Errorf("unable to decode textDate#a5b45e2b: field flags: %w", err)
		}
	}
	t.Relative = t.Flags.Has(0)
	t.ShortTime = t.Flags.Has(1)
	t.LongTime = t.Flags.Has(2)
	t.ShortDate = t.Flags.Has(3)
	t.LongDate = t.Flags.Has(4)
	t.DayOfWeek = t.Flags.Has(5)
	{
		value, err := DecodeRichText(b)
		if err != nil {
			return fmt.Errorf("unable to decode textDate#a5b45e2b: field text: %w", err)
		}
		t.Text = value
	}
	{
		value, err := b.Int()
		if err != nil {
			return fmt.Errorf("unable to decode textDate#a5b45e2b: field date: %w", err)
		}
		t.Date = value
	}
	return nil
}

// SetRelative sets value of Relative conditional field.
func (t *TextDate) SetRelative(value bool) {
	if value {
		t.Flags.Set(0)
		t.Relative = true
	} else {
		t.Flags.Unset(0)
		t.Relative = false
	}
}

// GetRelative returns value of Relative conditional field.
func (t *TextDate) GetRelative() (value bool) {
	if t == nil {
		return
	}
	return t.Flags.Has(0)
}

// SetShortTime sets value of ShortTime conditional field.
func (t *TextDate) SetShortTime(value bool) {
	if value {
		t.Flags.Set(1)
		t.ShortTime = true
	} else {
		t.Flags.Unset(1)
		t.ShortTime = false
	}
}

// GetShortTime returns value of ShortTime conditional field.
func (t *TextDate) GetShortTime() (value bool) {
	if t == nil {
		return
	}
	return t.Flags.Has(1)
}

// SetLongTime sets value of LongTime conditional field.
func (t *TextDate) SetLongTime(value bool) {
	if value {
		t.Flags.Set(2)
		t.LongTime = true
	} else {
		t.Flags.Unset(2)
		t.LongTime = false
	}
}

// GetLongTime returns value of LongTime conditional field.
func (t *TextDate) GetLongTime() (value bool) {
	if t == nil {
		return
	}
	return t.Flags.Has(2)
}

// SetShortDate sets value of ShortDate conditional field.
func (t *TextDate) SetShortDate(value bool) {
	if value {
		t.Flags.Set(3)
		t.ShortDate = true
	} else {
		t.Flags.Unset(3)
		t.ShortDate = false
	}
}

// GetShortDate returns value of ShortDate conditional field.
func (t *TextDate) GetShortDate() (value bool) {
	if t == nil {
		return
	}
	return t.Flags.Has(3)
}

// SetLongDate sets value of LongDate conditional field.
func (t *TextDate) SetLongDate(value bool) {
	if value {
		t.Flags.Set(4)
		t.LongDate = true
	} else {
		t.Flags.Unset(4)
		t.LongDate = false
	}
}

// GetLongDate returns value of LongDate conditional field.
func (t *TextDate) GetLongDate() (value bool) {
	if t == nil {
		return
	}
	return t.Flags.Has(4)
}

// SetDayOfWeek sets value of DayOfWeek conditional field.
func (t *TextDate) SetDayOfWeek(value bool) {
	if value {
		t.Flags.Set(5)
		t.DayOfWeek = true
	} else {
		t.Flags.Unset(5)
		t.DayOfWeek = false
	}
}

// GetDayOfWeek returns value of DayOfWeek conditional field.
func (t *TextDate) GetDayOfWeek() (value bool) {
	if t == nil {
		return
	}
	return t.Flags.Has(5)
}

// GetText returns value of Text field.
func (t *TextDate) GetText() (value RichTextClass) {
	if t == nil {
		return
	}
	return t.Text
}

// GetDate returns value of Date field.
func (t *TextDate) GetDate() (value int) {
	if t == nil {
		return
	}
	return t.Date
}

// RichTextClassName is schema name of RichTextClass.
const RichTextClassName = "RichText"

// RichTextClass represents RichText generic type.
//
// See https://core.telegram.org/type/RichText for reference.
//
// Constructors:
//   - [TextEmpty]
//   - [TextPlain]
//   - [TextBold]
//   - [TextItalic]
//   - [TextUnderline]
//   - [TextStrike]
//   - [TextFixed]
//   - [TextURL]
//   - [TextEmail]
//   - [TextConcat]
//   - [TextSubscript]
//   - [TextSuperscript]
//   - [TextMarked]
//   - [TextPhone]
//   - [TextImage]
//   - [TextAnchor]
//   - [TextMath]
//   - [TextCustomEmoji]
//   - [TextSpoiler]
//   - [TextMention]
//   - [TextHashtag]
//   - [TextBotCommand]
//   - [TextCashtag]
//   - [TextAutoURL]
//   - [TextAutoEmail]
//   - [TextAutoPhone]
//   - [TextBankCard]
//   - [TextMentionName]
//   - [TextDate]
//
// Example:
//
//	g, err := tg.DecodeRichText(buf)
//	if err != nil {
//	    panic(err)
//	}
//	switch v := g.(type) {
//	case *tg.TextEmpty: // textEmpty#dc3d824f
//	case *tg.TextPlain: // textPlain#744694e0
//	case *tg.TextBold: // textBold#6724abc4
//	case *tg.TextItalic: // textItalic#d912a59c
//	case *tg.TextUnderline: // textUnderline#c12622c4
//	case *tg.TextStrike: // textStrike#9bf8bb95
//	case *tg.TextFixed: // textFixed#6c3f19b9
//	case *tg.TextURL: // textUrl#3c2884c1
//	case *tg.TextEmail: // textEmail#de5a0dd6
//	case *tg.TextConcat: // textConcat#7e6260d7
//	case *tg.TextSubscript: // textSubscript#ed6a8504
//	case *tg.TextSuperscript: // textSuperscript#c7fb5e01
//	case *tg.TextMarked: // textMarked#34b8621
//	case *tg.TextPhone: // textPhone#1ccb966a
//	case *tg.TextImage: // textImage#81ccf4f
//	case *tg.TextAnchor: // textAnchor#35553762
//	case *tg.TextMath: // textMath#9d2eac97
//	case *tg.TextCustomEmoji: // textCustomEmoji#a26156c0
//	case *tg.TextSpoiler: // textSpoiler#4c2a5d62
//	case *tg.TextMention: // textMention#cd24cf44
//	case *tg.TextHashtag: // textHashtag#519524ea
//	case *tg.TextBotCommand: // textBotCommand#2ff29d3
//	case *tg.TextCashtag: // textCashtag#7b9e1801
//	case *tg.TextAutoURL: // textAutoUrl#ac6a83aa
//	case *tg.TextAutoEmail: // textAutoEmail#c556a45d
//	case *tg.TextAutoPhone: // textAutoPhone#24c26789
//	case *tg.TextBankCard: // textBankCard#b956812d
//	case *tg.TextMentionName: // textMentionName#1a9fbfc
//	case *tg.TextDate: // textDate#a5b45e2b
//	default: panic(v)
//	}
type RichTextClass interface {
	bin.Encoder
	bin.Decoder
	bin.BareEncoder
	bin.BareDecoder
	construct() RichTextClass

	// 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
}

// DecodeRichText implements binary de-serialization for RichTextClass.
func DecodeRichText(buf *bin.Buffer) (RichTextClass, error) {
	id, err := buf.PeekID()
	if err != nil {
		return nil, err
	}
	switch id {
	case TextEmptyTypeID:
		// Decoding textEmpty#dc3d824f.
		v := TextEmpty{}
		if err := v.Decode(buf); err != nil {
			return nil, fmt.Errorf("unable to decode RichTextClass: %w", err)
		}
		return &v, nil
	case TextPlainTypeID:
		// Decoding textPlain#744694e0.
		v := TextPlain{}
		if err := v.Decode(buf); err != nil {
			return nil, fmt.Errorf("unable to decode RichTextClass: %w", err)
		}
		return &v, nil
	case TextBoldTypeID:
		// Decoding textBold#6724abc4.
		v := TextBold{}
		if err := v.Decode(buf); err != nil {
			return nil, fmt.Errorf("unable to decode RichTextClass: %w", err)
		}
		return &v, nil
	case TextItalicTypeID:
		// Decoding textItalic#d912a59c.
		v := TextItalic{}
		if err := v.Decode(buf); err != nil {
			return nil, fmt.Errorf("unable to decode RichTextClass: %w", err)
		}
		return &v, nil
	case TextUnderlineTypeID:
		// Decoding textUnderline#c12622c4.
		v := TextUnderline{}
		if err := v.Decode(buf); err != nil {
			return nil, fmt.Errorf("unable to decode RichTextClass: %w", err)
		}
		return &v, nil
	case TextStrikeTypeID:
		// Decoding textStrike#9bf8bb95.
		v := TextStrike{}
		if err := v.Decode(buf); err != nil {
			return nil, fmt.Errorf("unable to decode RichTextClass: %w", err)
		}
		return &v, nil
	case TextFixedTypeID:
		// Decoding textFixed#6c3f19b9.
		v := TextFixed{}
		if err := v.Decode(buf); err != nil {
			return nil, fmt.Errorf("unable to decode RichTextClass: %w", err)
		}
		return &v, nil
	case TextURLTypeID:
		// Decoding textUrl#3c2884c1.
		v := TextURL{}
		if err := v.Decode(buf); err != nil {
			return nil, fmt.Errorf("unable to decode RichTextClass: %w", err)
		}
		return &v, nil
	case TextEmailTypeID:
		// Decoding textEmail#de5a0dd6.
		v := TextEmail{}
		if err := v.Decode(buf); err != nil {
			return nil, fmt.Errorf("unable to decode RichTextClass: %w", err)
		}
		return &v, nil
	case TextConcatTypeID:
		// Decoding textConcat#7e6260d7.
		v := TextConcat{}
		if err := v.Decode(buf); err != nil {
			return nil, fmt.Errorf("unable to decode RichTextClass: %w", err)
		}
		return &v, nil
	case TextSubscriptTypeID:
		// Decoding textSubscript#ed6a8504.
		v := TextSubscript{}
		if err := v.Decode(buf); err != nil {
			return nil, fmt.Errorf("unable to decode RichTextClass: %w", err)
		}
		return &v, nil
	case TextSuperscriptTypeID:
		// Decoding textSuperscript#c7fb5e01.
		v := TextSuperscript{}
		if err := v.Decode(buf); err != nil {
			return nil, fmt.Errorf("unable to decode RichTextClass: %w", err)
		}
		return &v, nil
	case TextMarkedTypeID:
		// Decoding textMarked#34b8621.
		v := TextMarked{}
		if err := v.Decode(buf); err != nil {
			return nil, fmt.Errorf("unable to decode RichTextClass: %w", err)
		}
		return &v, nil
	case TextPhoneTypeID:
		// Decoding textPhone#1ccb966a.
		v := TextPhone{}
		if err := v.Decode(buf); err != nil {
			return nil, fmt.Errorf("unable to decode RichTextClass: %w", err)
		}
		return &v, nil
	case TextImageTypeID:
		// Decoding textImage#81ccf4f.
		v := TextImage{}
		if err := v.Decode(buf); err != nil {
			return nil, fmt.Errorf("unable to decode RichTextClass: %w", err)
		}
		return &v, nil
	case TextAnchorTypeID:
		// Decoding textAnchor#35553762.
		v := TextAnchor{}
		if err := v.Decode(buf); err != nil {
			return nil, fmt.Errorf("unable to decode RichTextClass: %w", err)
		}
		return &v, nil
	case TextMathTypeID:
		// Decoding textMath#9d2eac97.
		v := TextMath{}
		if err := v.Decode(buf); err != nil {
			return nil, fmt.Errorf("unable to decode RichTextClass: %w", err)
		}
		return &v, nil
	case TextCustomEmojiTypeID:
		// Decoding textCustomEmoji#a26156c0.
		v := TextCustomEmoji{}
		if err := v.Decode(buf); err != nil {
			return nil, fmt.Errorf("unable to decode RichTextClass: %w", err)
		}
		return &v, nil
	case TextSpoilerTypeID:
		// Decoding textSpoiler#4c2a5d62.
		v := TextSpoiler{}
		if err := v.Decode(buf); err != nil {
			return nil, fmt.Errorf("unable to decode RichTextClass: %w", err)
		}
		return &v, nil
	case TextMentionTypeID:
		// Decoding textMention#cd24cf44.
		v := TextMention{}
		if err := v.Decode(buf); err != nil {
			return nil, fmt.Errorf("unable to decode RichTextClass: %w", err)
		}
		return &v, nil
	case TextHashtagTypeID:
		// Decoding textHashtag#519524ea.
		v := TextHashtag{}
		if err := v.Decode(buf); err != nil {
			return nil, fmt.Errorf("unable to decode RichTextClass: %w", err)
		}
		return &v, nil
	case TextBotCommandTypeID:
		// Decoding textBotCommand#2ff29d3.
		v := TextBotCommand{}
		if err := v.Decode(buf); err != nil {
			return nil, fmt.Errorf("unable to decode RichTextClass: %w", err)
		}
		return &v, nil
	case TextCashtagTypeID:
		// Decoding textCashtag#7b9e1801.
		v := TextCashtag{}
		if err := v.Decode(buf); err != nil {
			return nil, fmt.Errorf("unable to decode RichTextClass: %w", err)
		}
		return &v, nil
	case TextAutoURLTypeID:
		// Decoding textAutoUrl#ac6a83aa.
		v := TextAutoURL{}
		if err := v.Decode(buf); err != nil {
			return nil, fmt.Errorf("unable to decode RichTextClass: %w", err)
		}
		return &v, nil
	case TextAutoEmailTypeID:
		// Decoding textAutoEmail#c556a45d.
		v := TextAutoEmail{}
		if err := v.Decode(buf); err != nil {
			return nil, fmt.Errorf("unable to decode RichTextClass: %w", err)
		}
		return &v, nil
	case TextAutoPhoneTypeID:
		// Decoding textAutoPhone#24c26789.
		v := TextAutoPhone{}
		if err := v.Decode(buf); err != nil {
			return nil, fmt.Errorf("unable to decode RichTextClass: %w", err)
		}
		return &v, nil
	case TextBankCardTypeID:
		// Decoding textBankCard#b956812d.
		v := TextBankCard{}
		if err := v.Decode(buf); err != nil {
			return nil, fmt.Errorf("unable to decode RichTextClass: %w", err)
		}
		return &v, nil
	case TextMentionNameTypeID:
		// Decoding textMentionName#1a9fbfc.
		v := TextMentionName{}
		if err := v.Decode(buf); err != nil {
			return nil, fmt.Errorf("unable to decode RichTextClass: %w", err)
		}
		return &v, nil
	case TextDateTypeID:
		// Decoding textDate#a5b45e2b.
		v := TextDate{}
		if err := v.Decode(buf); err != nil {
			return nil, fmt.Errorf("unable to decode RichTextClass: %w", err)
		}
		return &v, nil
	default:
		return nil, fmt.Errorf("unable to decode RichTextClass: %w", bin.NewUnexpectedID(id))
	}
}

// RichText boxes the RichTextClass providing a helper.
type RichTextBox struct {
	RichText RichTextClass
}

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

// Encode implements bin.Encode for RichTextBox.
func (b *RichTextBox) Encode(buf *bin.Buffer) error {
	if b == nil || b.RichText == nil {
		return fmt.Errorf("unable to encode RichTextClass as nil")
	}
	return b.RichText.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.