client, _ := gotg.NewClient(apiID, apiHash, gotg.AsBot(token), &gotg.ClientOpts{
    LogConfig: &log.Config{
        MinLevel:  log.LevelDebug,
        Timestamp: true,
        Color:     true,
        Caller:    true,
        LogFile:   "/var/log/bot.log",
    },
})

// In handlers
func handler(u *adapter.Update) error {
    u.Log.Info("processing", "user", u.GetUserChat().ID)
    u.Log.Success("completed") // Green checkmark
    return nil
}

// Register steps
convManager.RegisterStep("reg:name", func(state *conv.State) error {
    name := state.Text()
    state.Set("user_name", name)
    return state.Next("reg:photo", "Send your photo", &conv.NextOpts{
        Filter: conv.Filters.Photo,
        Timeout: 5 * time.Minute,
    })
})

// Start conversation
update.StartConv("reg:name", "What's your name?", &adapter.ConvOpts{
    Reply: true,
    Filter: conv.Filters.Text,
})

i18n, _ := i18n.NewI18n(&i18n.Config{
    DefaultLocale: "en",
    LocalesDir: "./locales",
})

text := i18n.Get(userID, "welcome", "name", "Alice")
// en: "Hello, Alice!"
// es: "¡Hola, Alice!"

dispatcher.AddHandler(handlers.OnBusinessMessage(func(u *adapter.Update) error {
    return u.Reply("Business reply")
}))

gotg.NewClient(apiID, apiHash, gotg.AsBot(token), &gotg.ClientOpts{
    SendOutgoing: true,
})

dispatcher.AddHandler(handlers.OnOutgoing(func(u *adapter.Update) error {
    if u.EffectiveOutgoing.IsSend {
        log.Printf("Sent: %s", u.EffectiveMessage.Text)
    }
    return nil
}))

update.Dump("INCOMING") // Clean, formatted JSON output

// Messages
handlers.OnMessage(handler, filters.Message.Text)
handlers.OnEditedMessage(handler, filters.Message.Photo)
handlers.OnDeletedMessage(handler)

// Commands
handlers.OnCommand("help", handler, filters.Private)

// Callbacks & Inline
handlers.OnCallbackQuery(filters.Callback.Data("button_id"), handler)
handlers.OnInlineQuery(handler)
handlers.OnChosenInlineResult(handler)

// Chat Events
handlers.OnChatMemberUpdated(handler)
handlers.OnChatJoinRequest(handler)

// Reactions & Engagement
handlers.OnMessageReaction(handler)
handlers.OnChatBoost(handler)

// Business API
handlers.OnBusinessMessage(handler)
handlers.OnBusinessEditedMessage(handler)
handlers.OnBusinessDeletedMessage(handler)
handlers.OnBusinessConnection(handler)
handlers.OnBusinessCallbackQuery(handler)

// Outgoing Tracking
handlers.OnOutgoing(handler)

// Catch-all
handlers.OnUpdate(handler) // Receives all updates

// Message type filters
filters.Message.Text
filters.Message.Photo
filters.Message.Video
filters.Message.Document
filters.Message.Voice
filters.Message.Audio
filters.Message.Sticker
filters.Message.Animation

// Content filters
filters.Message.HasEntities
filters.Message.HasMention
filters.Message.HasHashtag
filters.Message.HasURL
filters.Message.Command
filters.Message.Reply

// Chat type filters
filters.Private
filters.Group
filters.Channel
filters.Supergroup

// Entity filters
filters.Message.From(userID)
filters.Message.Chat(chatID)

// Regex filters
filters.Message.Regex(`^/start (.+)`)

// Simple text message
msg, err := update.SendMessage(chatID, "Hello!")

// With formatting
msg, err := update.SendMessage(chatID, "<b>Bold</b> and <i>italic</i>", &adapter.SendOpts{
    ParseMode: adapter.ModeHTML,
})

// With keyboard
kb := keyboard.NewInline().
    Row().URL("Visit", "https://example.com").
    Row().Callback("Click me", "btn_data").
    Build()

msg, err := update.SendMessage(chatID, "Choose:", &adapter.SendOpts{
    ReplyMarkup: kb,
})

// Reply to a message
msg, err := update.Reply("Reply text")

// With media
media := &tg.InputMediaUploadedPhoto{File: uploadedFile}
msg, err := update.SendMedia(media, "Caption", &adapter.SendMediaOpts{
    ParseMode: adapter.ModeMarkdownV2,
})

// From local file
f, err := uploader.NewUploader(ctx.Raw).FromPath(ctx, "photo.jpg")
if err != nil {
    return err
}

media := &tg.InputMediaUploadedPhoto{File: f}
msg, err := ctx.SendMedia(chatID, &tg.MessagesSendMediaRequest{
    Media:   media,
    Message: "Check this out!",
})

// Download to file
err := msg.DownloadMedia(&adapter.DownloadToPath{Path: "./downloads/file.jpg"})

// Download to memory
var buf bytes.Buffer
err := msg.DownloadMedia(&adapter.DownloadToStream{Writer: &buf})

kb := keyboard.NewInline().
    Row().
        URL("GitHub", "https://github.com/pageton/gotg").
        URL("Docs", "https://pkg.go.dev/github.com/pageton/gotg").
    Row().
        Callback("Option 1", "opt_1").
        Callback("Option 2", "opt_2").
    Row().
        SwitchInline("Share", "check this out").
    Build()

kb := keyboard.NewReply().
    Row().
        Text("Button 1").
        Text("Button 2").
    Row().
        RequestContact("Share Contact").
        RequestLocation("Share Location").
    BuildReply(keyboard.ReplyOptions{
        Resize:    true,
        OneTime:   true,
        Selective: false,
    })

import "github.com/glebarez/sqlite"

client, _ := gotg.NewClient(apiID, apiHash, clientType, &gotg.ClientOpts{
    Session: session.SqlSession(sqlite.Open("bot.db")),
})

client, _ := gotg.NewClient(apiID, apiHash, clientType, &gotg.ClientOpts{
    InMemory: true,
})

// Pyrogram format
client, _ := gotg.NewClient(apiID, apiHash, clientType, &gotg.ClientOpts{
    Session: session.NewFromString("PYROGRAM_SESSION_STRING", session.Pyrogram),
})

// Telethon format
client, _ := gotg.NewClient(apiID, apiHash, clientType, &gotg.ClientOpts{
    Session: session.NewFromString("TELETHON_SESSION_STRING", session.Telethon),
})

errorHandler := func(ctx *adapter.Context, u *adapter.Update, err string) error {
    log.Printf("Error in update %d: %s", u.MsgID(), err)
    return dispatcher.ContinueGroups // Continue processing
}

dispatcher := dispatcher.NewNativeDispatcher(
    true, true,
    errorHandler,  // Error handler
    nil,           // Panic handler
    peerStorage,
    logger,
    false,
)

// Logging middleware
dp.AddHandlerToGroup(dispatcher.Handler{
    Handle: func(ctx *adapter.Context, u *adapter.Update) error {
        start := time.Now()
        log.Printf("Processing update %d", u.MsgID())
        
        // Call next handler (implementation depends on your flow)
        
        log.Printf("Completed in %v", time.Since(start))
        return nil
    },
}, -1) // Group -1 runs before all others