### Quick Start - Go SDK

Source: https://github.com/mosleyit/reolink_api_wrapper/blob/main/docs/index.html

Instructions for getting started with the Reolink API Wrapper using the Go SDK.

```APIDOC
## Quick Start - Go SDK

### Description
Instructions for using the production-ready Go SDK to interact with the Reolink Camera API.

### Method
```bash
go get github.com/mosleyit/reolink_api_wrapper
```

### Usage
Run the command above to add the SDK to your Go project. Refer to the Go SDK Docs for detailed usage examples.

```

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

### Quick Start: Authenticate and Get Device Info with Reolink Go SDK

Source: https://github.com/mosleyit/reolink_api_wrapper/blob/main/README.md

Example demonstrating how to create a Reolink client, authenticate with credentials, and retrieve device information. It shows basic usage of the System module and error handling.

```go
package main

import (
    "context"
    "fmt"
    "log"

    "github.com/mosleyit/reolink_api_wrapper"
)

func main() {
    // Create client
    client := reolink.NewClient("192.168.1.100",
        reolink.WithCredentials("admin", "password"))

    // Authenticate
    ctx := context.Background()
    if err := client.Login(ctx); err != nil {
        log.Fatal(err)
    }
    defer client.Logout(ctx)

    // Get device information
    info, err := client.System.GetDeviceInfo(ctx)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Camera: %s (Firmware: %s)\n", info.Model, info.FirmVer)
}
```

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

### Install Reolink API Go SDK

Source: https://github.com/mosleyit/reolink_api_wrapper/blob/main/docs/index.html

This command installs the production-ready Go SDK for the Reolink Camera API using the go get command. The SDK simplifies integration with Reolink cameras in Go applications.

```bash
go get github.com/mosleyit/reolink_api_wrapper
```

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

### Building Reolink Example Go Programs

Source: https://github.com/mosleyit/reolink_api_wrapper/blob/main/examples/README.md

Provides commands to compile Reolink SDK example programs into standalone executable binaries. This is useful for deploying or running the examples without needing the Go toolchain present on the target system.

```bash
# Build basic example
cd basic
go build -o basic main.go
./basic

# Build hardware test
cd hardware_test
go build -o hardware_test main.go
./hardware_test

```

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

### Initialize and Run a Go Example with Reolink API Wrapper

Source: https://github.com/mosleyit/reolink_api_wrapper/blob/main/examples/README.md

Provides the sequence of Go commands to initialize a new Go module, manage dependencies, and run a custom example project that uses the reolink_api_wrapper. This includes setting up the module, replacing local paths for the wrapper, and executing the main Go file.

```bash
cd my_example
go mod init my_example
go mod edit -replace github.com/mosleyit/reolink_api_wrapper=../..
go mod tidy
go run main.go
```

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

### Get Reolink Device Information in Go

Source: https://github.com/mosleyit/reolink_api_wrapper/blob/main/examples/README.md

Retrieves and displays essential device information, such as the camera model and firmware version, using the Reolink Go SDK. This snippet requires an authenticated client instance.

```go
info, err := client.System.GetDeviceInfo(ctx)
if err != nil {
    log.Fatal(err)
}
fmt.Printf("Model: %s, Firmware: %s\n", info.Model, info.FirmVer)

```

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

### Get Reolink Stream URLs in Go

Source: https://github.com/mosleyit/reolink_api_wrapper/blob/main/examples/README.md

Shows how to obtain RTSP and RTMP stream URLs for a Reolink camera using the Go SDK. It differentiates between main and sub streams and provides example URLs for accessing live video feeds.

```go
// Get RTSP URL for main stream
rtspURL := client.Streaming.GetRTSPURL(reolink.StreamMain, 0)
fmt.Printf("RTSP URL: %s\n", rtspURL)
// Output: rtsp://admin:password@192.168.1.100:554/Preview_01_main

// Get RTMP URL for sub stream
rtmpURL := client.Streaming.GetRTMPURL(reolink.StreamSub, 0)
fmt.Printf("RTMP URL: %s\n", rtmpURL)

```

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

### User Guide - Reolink Camera HTTP API

Source: https://github.com/mosleyit/reolink_api_wrapper/blob/main/docs/api_guide.txt

This section covers the fundamental aspects of interacting with the Reolink Camera HTTP API, including protocols, JSON structure, authentication, and command usage examples.

```APIDOC
## Introduction to Reolink Camera HTTP API

This document provides a comprehensive guide to the Reolink Camera HTTP API, enabling users to control and retrieve information from Reolink devices programmatically.

### Key Sections

*   **Protocol**: Details the communication protocol used (HTTP).
*   **JSON**: Explains the expected JSON format for requests and responses.
*   **Token**: Describes authentication mechanisms, likely involving tokens.
*   **Abbreviations & Definitions**: Provides a glossary of terms used throughout the API documentation.
*   **Command Usage Example**: Illustrates how to structure and send API commands.
```

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

### Add Reolink API Wrapper Dependency for New Example

Source: https://github.com/mosleyit/reolink_api_wrapper/blob/main/examples/README.md

Shows the Go import statement required to include the reolink_api_wrapper library in a new project example. This is a necessary step before building and running custom examples that interact with Reolink cameras.

```go
import "github.com/mosleyit/reolink_api_wrapper"
```

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

### Manage Audio Alarms and Playback (Go)

Source: https://context7.com/mosleyit/reolink_api_wrapper/llms.txt

Demonstrates how to get, configure, and manually play audio alarms using the Reolink API wrapper. It includes setting alarm sensitivity and triggering alarm playback for a specified number of times. The example also shows how to stop the audio alarm. Requires a reolink.Client instance.

```go
func manageAudioAlarms(client *reolink.Client) error {
    ctx := context.Background()
    channel := 0

    // Get audio alarm configuration
    audioConfig, err := client.Alarm.GetAudioAlarm(ctx, channel)
    if err != nil {
        return fmt.Errorf("failed to get audio alarm config: %w", err)
    }

    // Configure audio detection
    audioConfig.Enable = 1
    audioConfig.Sensitivity = 50

    err = client.Alarm.SetAudioAlarm(ctx, *audioConfig)
    if err != nil {
        return fmt.Errorf("failed to set audio alarm: %w", err)
    }

    // Play audio alarm manually
    err = client.Alarm.AudioAlarmPlay(ctx, reolink.AudioAlarmPlayParam{
        Channel:      channel,
        AlarmMode:    "manul",
        ManualSwitch: 1,  // Turn on
        Times:        3,  // Play 3 times
    })
    if err != nil {
        return fmt.Errorf("failed to play audio alarm: %w", err)
    }

    fmt.Println("Audio alarm playing")

    // Stop audio alarm after 10 seconds
    time.Sleep(10 * time.Second)
    err = client.Alarm.AudioAlarmPlay(ctx, reolink.AudioAlarmPlayParam{
        Channel:      channel,
        AlarmMode:    "manul",
        ManualSwitch: 0,  // Turn off
        Times:        0,
    })
    if err != nil {
        return fmt.Errorf("failed to stop audio alarm: %w", err)
    }

    return nil
}

```

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

### Configure and Start PTZ Patrol Tour (Go)

Source: https://context7.com/mosleyit/reolink_api_wrapper/llms.txt

Configures an automated PTZ patrol tour with multiple preset positions and dwell times. It first applies the patrol configuration and then initiates the patrol. The example also shows how to stop the patrol after a specified duration. Requires a reolink.Client instance.

```go
func configurePTZPatrol(client *reolink.Client) error {
    ctx := context.Background()
    channel := 0

    // Create patrol with multiple presets
    patrol := reolink.PtzPatrol{
        Channel: channel,
        Enable:  1,
        ID:      1,
        Running: 0,
        Name:    "Security Patrol",
        Preset: []reolink.PtzPatrolPreset{
            {
                ID:        1,  // Entrance
                DwellTime: 5,  // Stay for 5 seconds
                Speed:     32,
            },
            {
                ID:        2,  // Parking Lot
                DwellTime: 10, // Stay for 10 seconds
                Speed:     32,
            },
            {
                ID:        3,  // Back Door
                DwellTime: 5,
                Speed:     32,
            },
            {
                ID:        4,  // Garden
                DwellTime: 8,
                Speed:     32,
            },
        },
    }

    // Apply patrol configuration
    err := client.PTZ.SetPtzPatrol(ctx, patrol)
    if err != nil {
        return fmt.Errorf("failed to set patrol: %w", err)
    }

    // Start patrol
    err = client.PTZ.PtzCtrl(ctx, reolink.PtzCtrlParam{
        Channel: channel,
        Op:      reolink.PTZOpStartPatrol,
        ID:      1,
    })
    if err != nil {
        return fmt.Errorf("failed to start patrol: %w", err)
    }

    fmt.Println("Patrol started successfully")

    // Later: stop patrol
    time.Sleep(60 * time.Second)
    err = client.PTZ.PtzCtrl(ctx, reolink.PtzCtrlParam{
        Channel: channel,
        Op:      reolink.PTZOpStopPatrol,
    })
    if err != nil {
        return fmt.Errorf("failed to stop patrol: %w", err)
    }

    return nil
}

```

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

### Control PTZ Camera Movement in Go

Source: https://github.com/mosleyit/reolink_api_wrapper/blob/main/examples/README.md

Demonstrates how to initiate and stop PTZ (Pan-Tilt-Zoom) movements on a Reolink camera using the Go SDK. It includes starting a movement in a specified direction and speed, pausing, and then stopping the movement.

```go
// Move camera right
err := client.PTZ.StartPTZ(ctx, 0, "Right", 32)
if err != nil {
    log.Fatal(err)
}

// Stop movement after 2 seconds
time.Sleep(2 * time.Second)
err = client.PTZ.StopPTZ(ctx, 0)

```

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

### Start Online Upgrade

Source: https://github.com/mosleyit/reolink_api_wrapper/blob/main/docs/api_guide.txt

Triggers the online upgrade process for the device after a new version has been detected. This command initiates the download and installation of the available firmware update. The response includes a status code indicating the operation's success.

```json
{
  "cmd": "UpgradeOnline"
}
```

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

### FLV Stream Example for IPC Main Stream

Source: https://github.com/mosleyit/reolink_api_wrapper/blob/main/docs/api_guide.txt

A concrete example of an FLV URL to preview the main stream of an IP camera. This demonstrates the structure with specific IP address, channel ID, username, and password.

```URL
https://192.168.123.145/flv?port=1935&app=bcs&stream=channel0_main.bcs&user=admin&password=xxxx
```

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

### GetAbility API Post Data Example (JSON)

Source: https://github.com/mosleyit/reolink_api_wrapper/blob/main/docs/api_guide.txt

An example of the JSON data payload to be sent with the GetAbility API request. It specifies the command and the user for whom to retrieve abilities.

```JSON
[
{
"cmd":"GetAbility",
"param":{
"User":{
"userName":"admin"
}
}
}
]
```

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

### GetEnc API - Response Example

Source: https://github.com/mosleyit/reolink_api_wrapper/blob/main/docs/api_guide.txt

Example of a successful response when retrieving encoding configuration using the GetEnc API. It details the current settings for audio, main stream (H.265), and sub stream (H.264) for the specified channel.

```json
{
  "cmd": "GetEnc",
  "code": 0,
  "value": {
    "Enc": {
      "audio": 1,
      "channel": 0,
      "mainStream": {
        "bitRate": 6144,
        "frameRate": 25,
        "gop": 2,
        "height": 2160,
        "profile": "High",
        "size": "3840*2160",
        "vType": "h265",
        "width": 3840
      },
      "subStream": {
        "bitRate": 256,
        "frameRate": 10,
        "gop": 4,
        "height": 360,
        "profile": "High",
        "size": "640*360",
        "vType": "h264",
        "width": 640
      }
    }
  }
}
```

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

### FLV Stream Example for NVR Third Channel

Source: https://github.com/mosleyit/reolink_api_wrapper/blob/main/docs/api_guide.txt

An example FLV URL for previewing the video of the third channel of an NVR. Note that channel IDs start from 0, so the third channel is represented as 'channel2'.

```URL
https://192.168.0.206/flv?port=1935&app=bcs&stream=channel2_main.bcs&user=admin&password=xxxx
```

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

### Basic Reolink Camera Interaction in Go

Source: https://github.com/mosleyit/reolink_api_wrapper/blob/main/examples/README.md

Demonstrates fundamental Reolink SDK operations, including logging in, fetching device details and time configurations, and logging out. It requires camera IP, username, and password as environment variables.

```go
package main

import (
	"context"
	"fmt"
	"log"
	"os"
	"time"

	"github.com/reolink-api/reolink_api_go"
)

func main() {
	ctx := context.Background()

	host := os.Getenv("REOLINK_HOST")
	username := os.Getenv("REOLINK_USERNAME")
	password := os.Getenv("REOLINK_PASSWORD")

	if host == "" || username == "" || password == "" {
		log.Fatal("REOLINK_HOST, REOLINK_USERNAME, and REOLINK_PASSWORD must be set")
	}

	client, err := reolink_api_go.NewClient(ctx, host, username, password)
	if err != nil {
		log.Fatalf("Failed to create client: %v", err)
	}

	fmt.Println("Logging in...")
	token, err := client.Auth.Login(ctx)
	if err != nil {
		log.Fatalf("Login failed: %v", err)
	}
	fmt.Printf("Logged in successfully. Token: %s...\n", token)

	// Get Device Information
	info, err := client.System.GetDeviceInfo(ctx)
	if err != nil {
		log.Fatalf("Failed to get device info: %v", err)
	}

	fmt.Println("Device Information:")
	fmt.Printf("  Model: %s\n", info.Model)
	fmt.Printf("  Firmware: %s\n", info.FirmVer)
	fmt.Printf("  Hardware: %s\n", info.Hardware)

	// Get Time Configuration
	timeConfig, err := client.System.GetTime(ctx)
	if err != nil {
		log.Fatalf("Failed to get time config: %v", err)
	}
	fmt.Printf("  Time Zone: %s\n", timeConfig.TimeZone)

	// Logout
	err = client.Auth.Logout(ctx)
	if err != nil {
		log.Printf("Logout failed: %v", err)
	} else {
		fmt.Println("Logged out successfully.")
	}
}

```

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

### Quick Start - OpenAPI Generator

Source: https://github.com/mosleyit/reolink_api_wrapper/blob/main/docs/index.html

Instructions for generating a client in various languages using the OpenAPI Generator.

```APIDOC
## Quick Start - OpenAPI Generator

### Description
Instructions for generating a client in your preferred language (Python, TypeScript, Java) using the OpenAPI Generator and the provided OpenAPI specification.

### Usage
Use the following commands, replacing the language and output directory as needed:

#### Python
```bash
openapi-generator-cli generate -i reolink-camera-api-openapi.yaml -g python -o ./client
```

#### TypeScript
```bash
openapi-generator-cli generate -i reolink-camera-api-openapi.yaml -g typescript-axios -o ./client
```

#### Java
```bash
openapi-generator-cli generate -i reolink-camera-api-openapi.yaml -g java -o ./client
```

**Note:** Ensure you have `openapi-generator-cli` installed and the `reolink-camera-api-openapi.yaml` file downloaded.

```

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

### Manage Reolink Camera Users in Go

Source: https://github.com/mosleyit/reolink_api_wrapper/blob/main/examples/README.md

Demonstrates user management operations for a Reolink camera using the Go SDK, including fetching a list of existing users and adding a new user with specified credentials and permissions.

```go
// Get all users
users, err := client.Security.GetUsers(ctx)
if err != nil {
    log.Fatal(err)
}

// Add a new user
err = client.Security.AddUser(ctx, reolink.User{
    UserName: "guest",
    Password: "guestpass",
    Level:    "guest",
})

```

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

### Get DDNS Configuration (GetDdns)

Source: https://github.com/mosleyit/reolink_api_wrapper/blob/main/docs/api_guide.txt

Retrieves the Dynamic DNS (DDNS) configuration settings. This includes whether DDNS is enabled, the type of DDNS service, server address, domain name, username, and password. It is used to query the current DDNS setup.

```json
{
  "cmd": "GetDdns",
  "action": 1
}
```

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

### Configuration of Reolink Camera Environment Variables

Source: https://github.com/mosleyit/reolink_api_wrapper/blob/main/examples/README.md

Illustrates how to configure Reolink camera connection parameters using environment variables. This approach is recommended for managing sensitive information like host, username, and password, and also supports optional settings for HTTPS and TLS verification.

```bash
# Required
export REOLINK_HOST=192.168.1.100        # Camera IP address
export REOLINK_USERNAME=admin             # Camera username
export REOLINK_PASSWORD=yourpassword      # Camera password

# Optional
export REOLINK_HTTPS=true                 # Use HTTPS (default: false)
export REOLINK_SKIP_VERIFY=true           # Skip TLS verification (default: false)

```

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

### Get HDD/SD Card Information (Reolink API)

Source: https://github.com/mosleyit/reolink_api_wrapper/blob/main/docs/api_guide.txt

Retrieves information about the hard disk drives (HDD) or SD cards installed in the Reolink device. This includes details like capacity, format status, mount status, and storage type. The command requires a valid API token.

```JSON
{
"cmd":"GetHddInfo"
}
```

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

### Development Commands for Reolink Go SDK with Make

Source: https://github.com/mosleyit/reolink_api_wrapper/blob/main/README.md

Common development tasks for the Reolink Go SDK managed via a Makefile. Includes commands for displaying help, running tests, building examples, linting, formatting, and running all checks.

```bash
# Show all available commands
make help

# Run tests
make test

# Build all examples
make build

# Run linter
make lint

# Format code
make fmt

# Run all checks (format, lint, test) and build
make all
```

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

### Go SDK Docs

Source: https://github.com/mosleyit/reolink_api_wrapper/blob/main/docs/index.html

Access complete Go SDK documentation, including examples, type definitions, and API references.

```APIDOC
## Go SDK Docs

### Description
Complete Go SDK documentation with examples, type definitions, and API reference on pkg.go.dev.

### Endpoint
[Link to Go Docs]

### Usage
Click the link to view the Go SDK documentation for integration and examples.

```

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

### Comprehensive Reolink Hardware Integration Test in Go

Source: https://github.com/mosleyit/reolink_api_wrapper/blob/main/examples/README.md

Conducts thorough integration tests across various Reolink API modules, including System, Security, Network, Video, PTZ, Alarm, LED, and AI. It validates each endpoint and reports success or failure, helping confirm SDK compatibility with specific camera models and firmware.

```go
package main

import (
	"context"
	"fmt"
	"log"
	"os"
	"time"

	"github.com/reolink-api/reolink_api_go"
)

func main() {
	ctx := context.Background()

	host := os.Getenv("REOLINK_HOST")
	username := os.Getenv("REOLINK_USERNAME")
	password := os.Getenv("REOLINK_PASSWORD")

	if host == "" || username == "" || password == "" {
		log.Fatal("REOLINK_HOST, REOLINK_USERNAME, and REOLINK_PASSWORD must be set")
	}

	client, err := reolink_api_go.NewClient(ctx, host, username, password)
	if err != nil {
		log.Fatalf("Failed to create client: %v", err)
	}

	fmt.Println("Starting hardware test...")

	// System API Tests
	fmt.Println("\n--- System API Tests ---")
	if _, err := client.System.GetDeviceInfo(ctx); err != nil {
		log.Printf("System.GetDeviceInfo failed: %v\n", err)
	} else {
		fmt.Println("System.GetDeviceInfo passed")
	}

	// PTZ API Tests
	fmt.Println("\n--- PTZ API Tests ---")
	if err := client.PTZ.StartPTZ(ctx, 0, "Right", 32); err != nil {
		log.Printf("PTZ.StartPTZ failed: %v\n", err)
	} else {
		fmt.Println("PTZ.StartPTZ passed")
		time.Sleep(2 * time.Second)
		if err := client.PTZ.StopPTZ(ctx, 0); err != nil {
			log.Printf("PTZ.StopPTZ failed: %v\n", err)
		} else {
			fmt.Println("PTZ.StopPTZ passed")
		}
	}

	// Alarm API Tests (Motion Detection)
	fmt.Println("\n--- Alarm API Tests ---")
	mdConfig, err := client.Alarm.GetMd(ctx, 0)
	if err != nil {
		log.Printf("Alarm.GetMd failed: %v\n", err)
	} else {
		fmt.Println("Alarm.GetMd passed")
		mdConfig.Enable = 1 // Example: Enable motion detection
		mdConfig.Sensitivity = 50
		if err := client.Alarm.SetMd(ctx, 0, mdConfig); err != nil {
			log.Printf("Alarm.SetMd failed: %v\n", err)
		} else {
			fmt.Println("Alarm.SetMd passed")
		}
	}

	// Security API Tests (User Management)
	fmt.Println("\n--- Security API Tests ---")
	if _, err := client.Security.GetUsers(ctx); err != nil {
		log.Printf("Security.GetUsers failed: %v\n", err)
	} else {
		fmt.Println("Security.GetUsers passed")
	}

	// Add user example (optional, uncomment to test)
	// newUser := reolink_api_go.User{UserName: "guest", Password: "guestpass", Level: "guest"}
	// if err := client.Security.AddUser(ctx, newUser); err != nil {
	// 	log.Printf("Security.AddUser failed: %v\n", err)
	// } else {
	// 	fmt.Println("Security.AddUser passed")
	// }

	fmt.Println("\nHardware test finished.")

	// Logout
	err = client.Auth.Logout(ctx)
	if err != nil {
		log.Printf("Logout failed: %v", err)
	}
}

```

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

### Get Wi-Fi Signal Strength

Source: https://github.com/mosleyit/reolink_api_wrapper/blob/main/docs/api_guide.txt

Retrieves the current Wi-Fi signal strength. The signal strength is typically represented as an integer value. This is a GET request to the GetWifiSignal endpoint.

```json
{
"cmd":"GetWifiSignal",
"action":1
}
```

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

### HTTP POST Request Example

Source: https://github.com/mosleyit/reolink_api_wrapper/blob/main/docs/api_guide.txt

This example demonstrates the structure of an HTTP POST request to the Reolink API. It includes the endpoint, command, token, and parameter placeholders. The Content-Type can be 'application/octet-stream' or 'application/json'.

```http
POST /cgi-bin/api.cgi?cmd=xxx&token=20343295&paramxxx=xxx HTTP/1.1
```

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

### NVR Download

Source: https://github.com/mosleyit/reolink_api_wrapper/blob/main/docs/api_guide.txt

Initiates a download from the NVR.

```APIDOC
## POST /api.cgi?cmd=NvrDownload

### Description
Initiates a download from the NVR with specified parameters.

### Method
POST

### Endpoint
/api.cgi?cmd=NvrDownload

### Query Parameters
* **cmd** (string) - Required - The command to execute, should be 'NvrDownload'.
* **token** (string) - Required - Authentication token.

### Request Body
- **cmd** (string) - Required - Command, 'NvrDownload'.
- **action** (integer) - Required - Action type, typically 1 for download.
- **param** (object) - Required - Download parameters.
  - **NvrDownload** (object) - NVR download specific parameters.
    - **channel** (integer) - Required - The channel number to download from.
    - **streamType** (string) - Required - The type of stream to download ('main' or 'sub').
    - **StartTime** (object) - Required - The start time for the download.
      - **year** (integer) - Year.
      - **mon** (integer) - Month.
      - **day** (integer) - Day.
      - **hour** (integer) - Hour.
      - **min** (integer) - Minute.
      - **sec** (integer) - Second.
    - **EndTime** (object) - Required - The end time for the download.
      - **year** (integer) - Year.
      - **mon** (integer) - Month.
      - **day** (integer) - Day.
      - **hour** (integer) - Hour.
      - **min** (integer) - Minute.
      - **sec** (integer) - Second.

### Request Example
```json
{
  "cmd": "NvrDownload",
  "action": 1,
  "param": {
    "NvrDownload": {
      "channel": 0,
      "streamType": "sub",
      "StartTime": {
        "year": 2022,
        "mon": 8,
        "day": 9,
        "hour": 0,
        "min": 1,
        "sec": 21
      },
      "EndTime": {
        "year": 2022,
        "mon": 8,
        "day": 9,
        "hour": 0,
        "min": 5,
        "sec": 0
      }
    }
  }
}
```
```

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

### Configure Motion Detection Settings in Go

Source: https://github.com/mosleyit/reolink_api_wrapper/blob/main/examples/README.md

Details the process of retrieving, modifying, and setting motion detection (MD) configurations for a Reolink camera via the Go SDK. Users can enable/disable detection and adjust sensitivity levels.

```go
// Get current motion detection config
md, err := client.Alarm.GetMd(ctx, 0)
if err != nil {
    log.Fatal(err)
}

// Enable motion detection
md.Enable = 1
md.Sensitivity = 50

// Update configuration
err = client.Alarm.SetMd(ctx, 0, md)

```

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

### Get Wi-Fi Configuration

Source: https://github.com/mosleyit/reolink_api_wrapper/blob/main/docs/api_guide.txt

Retrieves the current Wi-Fi configuration, including the SSID and password. This is useful for understanding the current network settings of the device. The request is a GET request to the GetWifi endpoint.

```json
{
"cmd":"GetWifi",
"action":1
}
```

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

### Create and Authenticate Reolink Client (Go)

Source: https://context7.com/mosleyit/reolink_api_wrapper/llms.txt

Initializes a Reolink camera client with specified options like IP address, credentials, HTTPS, and timeout. It then attempts to log in to the camera and obtains an authentication token. The function includes error handling for login and ensures logout is deferred.

```go
package main

import (
    "context"
    "fmt"
    "log"
    "time"

    reolink "github.com/mosleyit/reolink_api_wrapper"
)

func main() {
    // Create client with options
    client := reolink.NewClient("192.168.1.100",
        reolink.WithCredentials("admin", "password"),
        reolink.WithHTTPS(true),
        reolink.WithTimeout(30*time.Second),
    )

    // Authenticate and obtain token
    ctx := context.Background()
    if err := client.Login(ctx); err != nil {
        log.Fatalf("Login failed: %v", err)
    }
    defer func() {
        if err := client.Logout(ctx); err != nil {
            log.Printf("Logout failed: %v", err)
        }
    }()

    // Verify authentication
    if client.IsAuthenticated() {
        fmt.Printf("Authenticated with token: %s\n", client.GetToken())
    }
}
```

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

### Configure Reolink Client with Options in Go

Source: https://github.com/mosleyit/reolink_api_wrapper/blob/main/README.md

Demonstrates advanced client configuration for the Reolink Go SDK, including setting credentials, enabling HTTPS, defining timeouts, and integrating a custom logger.

```go
client := reolink.NewClient("192.168.1.100",
    reolink.WithCredentials("admin", "password"),
    reolink.WithHTTPS(true),
    reolink.WithTimeout(30*time.Second),
    reolink.WithLogger(myLogger),
)
```