import { ReolinkClient } from 'reolink-nvr-api';

const client = new ReolinkClient({
  host: '192.168.1.100',
  username: 'admin',
  password: 'your-password',
  mode: 'long' // Token-based session with auto-refresh
});

await client.login();

// Get device information
const info = await client.getDevInfo();
console.log('Device:', info.name);

// Capture a snapshot
const jpeg = await client.snap(0); // channel 0
fs.writeFileSync('snapshot.jpg', Buffer.from(jpeg));

// PTZ control
await client.ptzCtrl(0, { cmd: 'Right', speed: 32 });

// Get RTSP stream URL
const rtspUrl = client.rtspUrl(0, { codec: 'h265', streamType: 'main' });
console.log('Stream:', rtspUrl);

await client.close();

import { ptzCtrl, getPtzPreset } from "reolink-nvr-api/ptz";

// Get available presets
const presets = await getPtzPreset(client, 0);
console.log(presets);

// Move to preset
await ptzCtrl(client, {
  channel: 0,
  op: "GotoPreset",
  presetId: 1,
});

// Pan right
await ptzCtrl(client, {
  channel: 0,
  op: "Right",
  speed: 20,
});

// Stop movement
await ptzCtrl(client, { channel: 0, op: "Stop" });

import { ReolinkEventEmitter } from "reolink-nvr-api/events";

const emitter = new ReolinkEventEmitter(client, {
  channels: [0, 1], // Monitor channels 0 and 1
  interval: 1000,   // Poll every second
});

emitter.on("motion", (channel, state) => {
  console.log(`Motion detected on channel ${channel}:`, state);
});

emitter.on("ai", (channel, state) => {
  console.log(`AI detection on channel ${channel}:`, state);
});

emitter.start();

import { rtspUrl, rtmpUrl, flvUrl } from "reolink-nvr-api/stream";

// Generate RTSP URL
const rtsp = rtspUrl({
  user: "admin",
  pass: "password",
  host: "192.168.1.100",
  channel: 0,
  h265: true, // Use H.265 codec
});

// Generate FLV URL
const flv = flvUrl({
  token: client.getToken(),
  user: "admin",
  host: "192.168.1.100",
  channel: 0,
  streamType: "main",
});

const client = new ReolinkClient({
  host: "192.168.1.100",        // Device IP or hostname
  username: "admin",             // Username
  password: "password",          // Password
  mode: "long",                  // "long" (session) or "short" (per-request)
  insecure: true,               // Allow self-signed certificates
  debug: false,                  // Enable debug logging
  timeout: 30000,                // Request timeout (ms)
});

// Direct API call
const response = await client.api("GetDevInfo", {});

// With parameters
const enc = await client.api("GetEnc", {
  channel: 0,
  action: 1,
});

const controller = client.createPlaybackController();

// Start playback
await controller.startPlayback(0, "2025-01-01T09:00:00Z");

// Seek to different time
await controller.seekPlayback(0, "2025-01-01T09:15:00Z");

// Stop playback
await controller.stopPlayback(0);

import { getPtzGuard, setPtzGuard, startPatrol } from "reolink-nvr-api/ptz";

// Enable guard mode
await setPtzGuard(client, 0, {
  benable: 1,
  timeout: 60, // Return to guard position after 60s
});

// Start patrol route
await startPatrol(client, 0, 0); // channel 0, patrol route 0

const client = new ReolinkClient({
  host: "192.168.1.100",
  username: "admin",
  password: "password",
  mode: "long", // default
});

const client = new ReolinkClient({
  host: "192.168.1.100",
  username: "admin",
  password: "password",
  mode: "short",
});

new ReolinkClient(options: ReolinkOptions)

import { ReolinkHttpError } from "reolink-api";

try {
  await client.api("SomeCommand");
} catch (error) {
  if (error instanceof ReolinkHttpError) {
    console.error(`Error code: ${error.code}`);
    console.error(`Response code: ${error.rspCode}`);
    console.error(`Detail: ${error.detail}`);
  }
}

import { ReolinkClient } from "reolink-api";

const client = new ReolinkClient({
  host: "192.168.1.100",
  username: "admin",
  password: "password",
});

await client.login();

const controller = client.createPlaybackController();

// Start playback from a specific time
await controller.startPlayback(0, "2025-11-10T09:00:00Z");

// Seek to a different time
await controller.seekPlayback(0, "2025-11-10T09:15:00Z");

// Stop playback on specific channel
await controller.stopPlayback(0);

// Stop all playback
await controller.stopPlayback();

await client.close();

import { ReolinkPlaybackController } from "reolink-api/playback";

const controller = new ReolinkPlaybackController(client);
await controller.startPlayback(0, "2025-11-10T09:00:00Z");

import { ReolinkClient } from "reolink-api";

const client = new ReolinkClient({
  host: "192.168.1.100",
  username: "admin",
  password: "password",
});

await client.login();

// Get guard mode status
const guard = await client.getPtzGuard(0);
console.log(guard); // { benable: 1, timeout: 60, channel: 0, ... }

// Enable guard mode with timeout (RLC-823A/S1: guard binds to current camera position)
// Note: cmdStr: "setPos" and bSaveCurrentPos: 1 are automatically included
await client.setPtzGuard(0, {
  benable: 1,
  timeout: 60,
});

// Toggle guard mode
await client.toggleGuardMode(0);

// Get patrol configuration
const patrol = await client.getPtzPatrol(0);
console.log(patrol); // Array of PtzPatrolConfig objects

// Set patrol configuration (RLC-823A/S1 format)
// Note: On RLC-823A/S1 models, use preset array with id/speed/dwellTime
await client.setPtzPatrol(0, {
  channel: 0,
  id: 0,
  enable: 1,
  preset: [
    { id: 0, speed: 32, dwellTime: 10 },
    { id: 1, speed: 32, dwellTime: 10 },
  ],
});

// Start patrol route
await client.startPatrol(0, 0);

// Stop patrol route
await client.stopPatrol(0, 0);

await client.close();