### Running Go-TDLib Example Application with Docker

Source: https://github.com/zelenin/go-tdlib/blob/master/README.md

These commands provide instructions for building and running the `go-tdlib` example application using Docker. It navigates into the example directory, builds a Docker image, and then runs a container, passing necessary API credentials as environment variables.

```Shell
cd example
docker build --network host --progress plain --tag tdlib-test .
docker run --rm -it -e "API_ID=00000" -e "API_HASH=abcdef0123456789" tdlib-test ash
./app
```

--------------------------------

### Configuring Custom TDLib Path for Go Build (PowerShell)

Source: https://github.com/zelenin/go-tdlib/blob/master/README.md

This PowerShell example shows how to set environment variables for CGO_ENABLED, CGO_CFLAGS, and CGO_LDFLAGS before executing a 'go build' command on Windows. It includes specific build flags like -trimpath and -ldflags for optimization and specifies the output executable name, along with a note about DLL placement for runtime.

```powershell
$env:CGO_ENABLED=1; $env:CGO_CFLAGS="-IC:/td/tdlib/include"; $env:CGO_LDFLAGS="-LC:/td/tdlib/bin -ltdjson"; go build -trimpath -ldflags="-s -w" -o demo.exe .\cmd\demo.go
```

--------------------------------

### Configuring Custom TDLib Path for Go Build (Shell)

Source: https://github.com/zelenin/go-tdlib/blob/master/README.md

This snippet demonstrates how to set environment variables CGO_CFLAGS and CGO_LDFLAGS for the 'go build' command in a Unix-like shell. This is essential for specifying custom include and library paths when TDLib is installed in a non-standard location, ensuring the Go application can correctly link against the TDLib shared library.

```shell
CGO_CFLAGS=-I/path/to/tdlib/include \
CGO_LDFLAGS="-Wl,-rpath,/path/to/tdlib/lib -L/path/to/tdlib/lib -ltdjson" \
go build ...
```

--------------------------------

### Initializing and Using TDLib Client (Go)

Source: https://github.com/zelenin/go-tdlib/blob/master/README.md

This comprehensive Go snippet demonstrates how to initialize a TDLib client, configure its parameters (e.g., database and files directories, API ID/hash), set log verbosity, and perform basic operations like fetching TDLib version information and retrieving the current user's details. It also includes a mechanism for graceful shutdown upon receiving interrupt signals.

```go
package main

import (
	"context"
	"github.com/zelenin/go-tdlib/client"
	"log"
	"os"
	"os/signal"
	"path/filepath"
	"syscall"
)

const (
	apiId   = 00000
	apiHash = "8pu9yg32qkuukj83ozaqo5zzjwhkxhnk"
)

func main() {
	tdlibParameters := &client.SetTdlibParametersRequest{
		UseTestDc:              false,
		DatabaseDirectory:      filepath.Join(".tdlib", "database"),
		FilesDirectory:         filepath.Join(".tdlib", "files"),
		UseFileDatabase:        true,
		UseChatInfoDatabase:    true,
		UseMessageDatabase:     true,
		UseSecretChats:         false,
		ApiId:                  apiId,
		ApiHash:                apiHash,
		SystemLanguageCode:     "en",
		DeviceModel:            "Server",
		SystemVersion:          "1.0.0",
		ApplicationVersion:     "1.0.0",
	}
    // client authorizer
    authorizer := client.ClientAuthorizer(tdlibParameters)
    go client.CliInteractor(authorizer)

    // or bot authorizer
    // botToken := "000000000:gsVCGG5YbikxYHC7bP5vRvmBqJ7Xz6vG6td"
    // authorizer := client.BotAuthorizer(tdlibParameters, botToken)

	_, err := client.SetLogVerbosityLevel(&client.SetLogVerbosityLevelRequest{
		NewVerbosityLevel: 1,
	})
	if err != nil {
		log.Fatalf("SetLogVerbosityLevel error: %s", err)
	}

	tdlibClient, err := client.NewClient(authorizer)
	if err != nil {
		log.Fatalf("NewClient error: %s", err)
	}

	versionOption, err := client.GetOption(&client.GetOptionRequest{
		Name: "version",
	})
	if err != nil {
		log.Fatalf("GetOption error: %s", err)
	}

	commitOption, err := client.GetOption(&client.GetOptionRequest{
		Name: "commit_hash",
	})
	if err != nil {
		log.Fatalf("GetOption error: %s", err)
	}

	log.Printf("TDLib version: %s (commit: %s)", versionOption.(*client.OptionValueString).Value, commitOption.(*client.OptionValueString).Value)

	if commitOption.(*client.OptionValueString).Value != client.TDLIB_VERSION {
		log.Printf("TDLib version supported by the library (%s) is not the same as TDLib version (%s)", client.TDLIB_VERSION, commitOption.(*client.OptionValueString).Value)
	}

	me, err := tdlibClient.GetMe(context.Background())
	if err != nil {
		log.Fatalf("GetMe error: %s", err)
	}

	log.Printf("Me: %s %s", me.FirstName, me.LastName)

	ch := make(chan os.Signal, 2)
	signal.Notify(ch, syscall.SIGINT, syscall.SIGTERM)
	<-ch
	tdlibClient.Close(context.Background())
	os.Exit(1)
}
```

--------------------------------

### Configuring Proxy Support for Go-TDLib Client

Source: https://github.com/zelenin/go-tdlib/blob/master/README.md

This code illustrates how to configure proxy settings for the `go-tdlib` client. It defines a SOCKS5 proxy with a specified server address, port, and authentication credentials, then initializes a new client instance with these proxy settings.

```Go
proxy := client.WithProxy(&client.AddProxyRequest{
    Server: "1.1.1.1",
    Port:   1080,
    Enable: true,
    Type: &client.ProxyTypeSocks5{
        Username: "username",
        Password: "password",
    },
})

tdlibClient, err := client.NewClient(authorizer, proxy)
```

--------------------------------

### Implementing QR Code Login with TDLib (Go)

Source: https://github.com/zelenin/go-tdlib/blob/master/README.md

This Go snippet illustrates how to set up TDLib client authorization using a QR code. It configures TDLib parameters and then uses the 'client.QrAuthorizer' along with a callback function to generate a QR code image file (qr.png) from the provided login link, facilitating a seamless QR code-based authentication flow.

```go
package main

import (
	"github.com/skip2/go-qrcode"
	"log"
	"path/filepath"

	"github.com/zelenin/go-tdlib/client"
)

const (
	apiId   = 00000
	apiHash = "8pu9yg32qkuukj83ozaqo5zzjwhkxhnk"
)

func main() {
	tdlibParameters := &client.SetTdlibParametersRequest{
		UseTestDc:              false,
		DatabaseDirectory:      filepath.Join(".tdlib", "database"),
		FilesDirectory:         filepath.Join(".tdlib", "files"),
		UseFileDatabase:        true,
		UseChatInfoDatabase:    true,
		UseMessageDatabase:     true,
		UseSecretChats:         false,
		ApiId:                  apiId,
		ApiHash:                apiHash,
		SystemLanguageCode:     "en",
		DeviceModel:            "Server",
		SystemVersion:          "1.0.0",
		ApplicationVersion:     "1.0.0",
	}
	// client authorizer
	authorizer := client.QrAuthorizer(tdlibParameters, func(link string) error {
		return qrcode.WriteFile(link, qrcode.Medium, 256, "qr.png")
	})

	tdlibClient, err := client.NewClient(authorizer)
	if err != nil {
		log.Fatalf("NewClient error: %s", err)
	}
}
```

--------------------------------

### Configuring Custom TDLib Path for Go Build (Windows Command Prompt)

Source: https://github.com/zelenin/go-tdlib/blob/master/README.md

This snippet provides the necessary environment variable configurations for building Go applications with TDLib on Windows using the command prompt. It sets CGO_ENABLED to 1 and specifies the include and library paths for TDLib, allowing the Go compiler to find the required TDLib components.

```shell
CGO_ENABLED=1
CGO_CFLAGS=-IC:/path/to/tdlib/build/tdlib/include
CGO_LDFLAGS=-LC:/path/to/tdlib/build/tdlib/bin -ltdjson
```

--------------------------------

### Receiving Updates with Go-TDLib Client

Source: https://github.com/zelenin/go-tdlib/blob/master/README.md

This snippet demonstrates how to initialize a `go-tdlib` client with a callback handler to receive and process updates. It defines a callback function `resHandCallback` that logs the type of the received result and then creates a new client, attaching this handler. Error handling for client creation is also included.

```Go
resHandCallback := func(result client.Type) {
    log.Printf("%#v", result.GetType())
}

tdlibClient, err := client.NewClient(authorizer, client.WithResultHandler(client.NewCallbackResultHandler(resHandCallback)))
if err != nil {
    log.Fatalf("NewClient error: %s", err)
}
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.