daikin-local-control 0.1.1

package/README.md

@@ -0,0 +1,317 @@
+# daikin-local-control
+
+A TypeScript client for controlling Daikin air-conditioner Wi-Fi adapters **over
+the local network**, with no cloud dependency. It implements the same
+local-control protocol as the **DAIKIN Mobile Controller** app, so it works with
+the units and Wi-Fi adapters that app supports — split / multi-split and SkyAir
+units fitted with adapters such as the BRP072A42, BRP072C42 and BRP084 — in the
+[markets where that app is used](#coverage--limitations).
+
+Daikin Wi-Fi adapters come in two generations, and the package has a client for
+each:
+
+- **`ClassicDaikinClient`** — classic adapters (BRP072A42, BRP072C42, BRP069).
+  Full core control plus typed [extended controls](#extended-controls).
+- **`DsiotDaikinClient`** — newer DSIOT adapters (BRP084). Power, mode,
+  setpoint, humidity, fan, swing and louver positions;
+  [UNSUPPORTED.md](UNSUPPORTED.md) lists what is not mapped yet.
+
+You normally don't pick one yourself: `createDaikinClient` chooses the right
+client for each discovered device.
+
+## Usage
+
+```ts
+import { discoverDevices, createDaikinClient } from "daikin-local-control";
+
+// 1. Find adapters on the LAN (UDP broadcast DAIKIN_UDP/common/basic_info :30050).
+const [device] = await discoverDevices();
+if (device === undefined) {
+  throw new Error("No adapter answered");
+}
+
+// 2. Build the right client: createDaikinClient picks the classic or the DSIOT
+//    client from the device. Pass localPassword only when the adapter has a
+//    child lock code (see Credentials below).
+const client = createDaikinClient(device, {
+  terminalUuid: savedUuid, // generated once and stored (see Credentials below)
+  localPassword: device.requiresLocalPassword ? "<child lock code>" : undefined,
+});
+
+// 3. Capabilities are data — branch on them, don't special-case device types.
+const capabilities = await client.getCapabilities();
+if (capabilities.swingModes.includes("both")) {
+  /* this unit swings on both axes */
+}
+
+// 4. Read and control.
+const state = await client.getState();
+await client.setState({ power: true, mode: "cool", targetTemperatureInC: 24 });
+
+const { indoorTemperatureInC } = await client.getSensors();
+
+// 5. Close the connection to the adapter when you're done with the unit.
+await client.close();
+```
+
+### Discovery
+
+`discoverDevices()` resolves with one `DaikinDevice` for each adapter that
+answered, and with an empty array when none did.
+
+| It | So |
+| --- | --- |
+| Resolves after `timeoutInMs`, never earlier | Pass `discoverDevices({ timeoutInMs: 1000 })` to wait less than the default 3000 |
+| Broadcasts to `255.255.255.255` | It does not find an adapter on another subnet or VLAN |
+| Binds UDP port 30000 | It rejects with the socket's error when the socket fails |
+
+Write the device by hand when you already know its address, or when discovery
+cannot reach it:
+
+```ts
+import { createDaikinClient, type DaikinDevice } from "daikin-local-control";
+
+const device: DaikinDevice = { host: "192.168.1.50", protocol: "classic" };
+const client = createDaikinClient(device, { terminalUuid: savedUuid });
+```
+
+Set `protocol` to `dsiot` for a BRP084 and to `classic` for every other
+adapter. A device without flags is an adapter that requires neither
+registration nor a child lock code. If yours requires either, set
+`requiresRegistration: true` / `requiresLocalPassword: true` and set up
+[credentials](#credentials) to match; add `usesHttps: true` if it also speaks
+HTTPS. The flags are independent, and discovery reads them all from the adapter
+for you.
+
+### Credentials
+
+An adapter can need up to three things. Discovery tells you which ones apply
+(`device.requiresRegistration`, `device.requiresLocalPassword`).
+
+**Terminal uuid (always).** It identifies your app to the adapter. Any random
+UUID works. Generate it **once**, store it, and reuse it on every run: an
+adapter that requires registration remembers it, so a new uuid means registering
+again.
+
+```ts
+import { randomUUID } from "node:crypto";
+
+const savedUuid = loadFromConfiguration() ?? saveToConfiguration(randomUUID());
+```
+
+**KEY (when `device.requiresRegistration` is `true`).** These
+adapters only answer terminals they have registered. Each adapter's KEY is
+printed on its label, next to the SSID (also in the operation manual). Register
+your uuid with it once. Until you do, every call fails with HTTP 401/403.
+Each uuid is registered separately, so an adapter already set up in the DAIKIN
+Mobile Controller app still needs registering here.
+
+```ts
+import { ClassicDaikinClient } from "daikin-local-control";
+
+if (device.requiresRegistration && client instanceof ClassicDaikinClient) {
+  await client.registerTerminal("<KEY from the label>");
+
+  // To unregister later: this uuid (default), every other uuid, or all of them.
+  // await client.unregisterTerminal("others");
+}
+```
+
+Registration applies to classic adapters only; DSIOT adapters don't use it.
+
+Some of these adapters also switch to HTTPS (`device.usesHttps`); see
+[Local HTTPS](#local-https).
+
+**Child lock code (when `device.requiresLocalPassword` is `true`).** The protocol
+calls it the local password (`lpw`). It is the 4-digit code set under Child lock
+in the DAIKIN Mobile Controller app. It is **not** printed on the label, and it
+is not your Wi-Fi or Out-of-Home password. Pass it as `localPassword` to
+`createDaikinClient`. If it's forgotten, the adapter has to be reset.
+
+### State and capabilities
+
+`getState()` resolves with a `DaikinState`:
+
+| Field | Holds |
+| --- | --- |
+| `power` | `true` or `false` |
+| `mode` | `auto`, `dehumidify`, `cool`, `heat` or `fan` |
+| `targetTemperatureInC` | A number, or `null` in a mode without a setpoint |
+| `targetHumidity` | `off`, `autoLow`, `auto`, `autoHigh` or `continuous`, or `null` when the unit has no humidity setting. A Japanese unit set to a percentage reads as `{ percent: 50 }`; `getCapabilities()` never lists a percentage, so `setState()` sends one unchecked: see [UNSUPPORTED.md](UNSUPPORTED.md) |
+| `fanSpeed` | `auto`, `silent`, or `level1` to `level5` |
+| `swingMode` | `off`, `vertical`, `horizontal` or `both`: `vertical` moves the air up and down, `horizontal` left and right |
+| `verticalPosition` | `stop`, `position1` to `position5`, `swing`, `naturalWind`, `auto` or `floorWarming`, or `null` where the unit reports none |
+| `horizontalPosition` | `stop`, `position1` to `position5`, `swing` or `auto`, or `null` where the unit reports none |
+
+`getCapabilities()` resolves with a `DaikinCapabilities`, which lists the
+values this unit takes under the name of the state field each one limits:
+
+| Field | Holds |
+| --- | --- |
+| `modes` | The modes the unit offers |
+| `fanSpeeds`, `swingModes`, `verticalPositions`, `horizontalPositions` | The values the unit takes, empty when it has no such control |
+| `targetTemperatureInC` | For each mode, `{ min, max, step }` in °C, or `null` where the mode has no setpoint |
+| `targetHumidity` | For each mode, the humidity settings it takes, empty where it takes none |
+| `specialOutlet`, `energyMonitoring`, `demandControl`, `scheduleTimer` | `true` when the unit has the feature |
+| `model` | The adapter's own code for the unit's model |
+
+`getSensors()` resolves with `indoorTemperatureInC`, `outdoorTemperatureInC`
+and `indoorHumidityInPercent`, each `null` when the unit does not report it.
+
+### Changing state
+
+Pass `setState()` only the fields to change: a field left out keeps the value
+the unit holds for the target mode.
+
+Check a value against `getCapabilities()` before sending it: `setState()`
+resolves without an error when it drops a field, and sends any other value as
+given, whether or not the unit lists it.
+
+| Field | `setState()` drops it |
+| --- | --- |
+| `targetTemperatureInC` | In `fan` and `dehumidify` |
+| `targetHumidity` | In `fan` |
+| `fanSpeed` | In `dehumidify`, and on a DSIOT adapter in `cool` while a humidity setting is on: the fan runs on `auto` |
+| `verticalPosition`, `horizontalPosition` | On a classic adapter, when the unit has no 3D airflow. On a DSIOT adapter, a fixed vertical position the unit lacks, and every fixed horizontal position |
+
+### Extended controls
+
+Beyond core climate, `ClassicDaikinClient` exposes the adapter's other `set_*`
+endpoints as typed methods, plus a raw `command()` hatch for anything without a
+wrapper. Narrow to the concrete class to reach them:
+
+```ts
+import { ClassicDaikinClient } from "daikin-local-control";
+
+if (client instanceof ClassicDaikinClient) {
+  await client.setLed(false);
+  await client.setHolidayMode(true);
+  await client.setDemandControl({
+    enabled: true,
+    maxPowerInPercent: 70,
+    mode: "manual",
+  });
+  await client.setSpecialMode("powerful", true);
+  await client.setOutOfHomeAccess(false); // home network only
+  await client.setEnergyPrice(0.3); // per kWh
+  await client.setMetadata({
+    name: "Living Room",
+    group: { name: "Upstairs", enabled: true },
+  });
+  await client.reboot();
+
+  // Any other endpoint, by its path: the reply's key=value fields come back.
+  const basicInfo = await client.command("/common/basic_info");
+}
+```
+
+[UNSUPPORTED.md](UNSUPPORTED.md) lists the endpoints without a typed method and
+what is not known about each.
+
+`DsiotDaikinClient` has `reboot()` and the raw `multireqGet` / `multireqUpdate`
+hatches for any `dgc_status` leaf.
+
+### Errors and retries
+
+A client method that fails rejects with a `DaikinError`; branch on
+`httpStatusCode`:
+
+| `httpStatusCode` | Meaning |
+| --- | --- |
+| 401 | The adapter rejected the credentials: `ret=AUTH NG` or `LPW NG`, or DSIOT `rsc` 401 or 4001 |
+| 502 | The adapter answered with an error: a `ret` or `rsc` other than OK, or a reply that does not parse |
+| 503 | The adapter refused or dropped the connection (a `DaikinConnectionError`), or DSIOT answered `rsc` 503 |
+| 504 | The request timed out, or the TLS handshake failed |
+| Any other | The adapter's own HTTP status, such as 403 |
+
+Two failures are not a `DaikinError`: `discoverDevices()` rejects with the
+socket's error, and `multireqUpdate()` throws an `Error` for a path that names
+a resource without a leaf, such as `dgc_status`.
+
+Only a `DaikinConnectionError` is retried, up to five times by default.
+[DESIGN.md](DESIGN.md#retries) says why.
+
+| To | Pass |
+| --- | --- |
+| Change how often and how long a client retries | `retry: { delaysInMs: [0, 500] }` to `createDaikinClient`: one wait, in milliseconds, before each retry |
+| Stop a client retrying | `retry: { delaysInMs: [] }` to `createDaikinClient` |
+| Send one request that is not safe to repeat | `{ retry: false }` as the last argument of `command()`, `multireqGet()` or `multireqUpdate()` |
+
+## Coverage & limitations
+
+It supports the same markets and Wi-Fi adapters as the DAIKIN Mobile Controller
+app, so it is **not valid for every Daikin region or app**.
+
+| Region         | Markets using the DAIKIN Mobile Controller app                 |
+| -------------- | -------------------------------------------------------------- |
+| Southeast Asia | Thailand, Singapore, the Philippines                           |
+| East Asia      | Hong Kong, Taiwan                                              |
+| Oceania        | Australia, New Zealand                                         |
+
+The app is published by Daikin Thailand and may be available in other countries
+too; if your local Daikin site points you to it, this package should apply. Units
+sold for other apps likely use a different protocol, e.g. Onecta / Daikin Online
+Controller (Europe), GO DAIKIN (Malaysia) or Daikin Comfort Control / Daikin One
+(North America).
+
+This package is still young, so expect some rough edges. If something doesn't
+work with your unit, please
+[open an issue](https://github.com/cheziyi/daikin-local-control/issues).
+[UNSUPPORTED.md](UNSUPPORTED.md) lists what isn't supported yet.
+
+## Local HTTPS
+
+Only some classic adapters use HTTPS: those reporting `adp_kind=3` with
+`en_secure=1`. Discovery sets `device.usesHttps` for them. Every other adapter,
+DSIOT included, talks plain HTTP on the LAN, even when it requires registration.
+
+Over HTTPS the adapter presents a certificate issued by Daikin's own CA, which
+this package can't ship. So by default **the certificate is not verified**: the
+connection is encrypted, but another device on your LAN could impersonate the
+adapter. If you have the CA certificate, pass it to turn verification on:
+
+```ts
+import { readFileSync } from "node:fs";
+
+const client = createDaikinClient(device, {
+  terminalUuid: savedUuid,
+  tls: { ca: readFileSync("daikin-ca.pem") },
+});
+```
+
+With a CA, the certificate chain is verified but the hostname isn't, because the
+adapter's certificate doesn't name its LAN address.
+
+## Development
+
+Uses [pnpm](https://pnpm.io) and Node 22.19 or later (see `.nvmrc`; `fnm use` / `nvm use` picks it up).
+
+```bash
+pnpm build            # tsc -> dist
+pnpm test             # typecheck + vitest
+pnpm check            # biome lint + format + import sorting
+pnpm fix              # check, applying safe fixes
+```
+
+`pnpm install` sets up a [lefthook](https://lefthook.dev) pre-commit hook that runs `pnpm fix` on staged files.
+
+## Legal disclaimer
+
+An independent, community project for local interoperability and home automation.
+It is not affiliated with, authorized, or endorsed by Daikin Industries, Ltd. All
+product names and trademarks are the property of their respective owners; their use
+here is for identification and compatibility only.
+
+**Local-only.** The package talks only to the adapter over the LAN — it never contacts
+any manufacturer cloud, remote server, or online API — and acts as an ordinary
+client of the adapter's own endpoints.
+
+**No proprietary material.** It ships no manufacturer keys, tokens, certificates, or
+binaries. The protocol was documented independently, for interoperability.
+
+Provided "as is", without warranty of any kind (see [LICENSE](LICENSE)); use it at
+your own risk.
+
+## License
+
+[GPL-3.0-or-later](LICENSE). Copyright © 2026 the contributors.

package/UNSUPPORTED.md

@@ -0,0 +1,43 @@
+# Unsupported
+
+Everything below is left out because its exact request or reply is not known.
+To add one, pin down the request and reply first, then delete its row.
+
+## Left out
+
+| Feature | What is unknown | Reach it with |
+| --- | --- | --- |
+| DSIOT special air outlet | Which leaf reports it. `getCapabilities` reports `specialOutlet: false`. | `DsiotDaikinClient.multireqGet()` |
+| Classic `/common/set_location` | The parameter name. | `ClassicDaikinClient.command()` |
+| DSIOT `/config/*` endpoints: time zone, date and time, network settings, Wi-Fi scan, firmware update | The request bodies. | Not reachable |
+| DSIOT fixed horizontal louver positions | Which position each value 1-14 stands for. `getState` reports `stop` for any of them, and a control that sets `stop` keeps the position. | `DsiotDaikinClient.multireqUpdate()` |
+| DSIOT dehumidify setpoint write | Whether `p_1E` accepts a write; it is treated as read-only, so `setState` drops a `targetTemperatureInC` in dehumidify. | `DsiotDaikinClient.multireqUpdate()` |
+| Classic `shum_asean`, the humidity setting of a `subtype=qa` unit | What each value stands for. `setState` sends such a unit no humidity setting, and `getCapabilities` lists none. | `ClassicDaikinClient.command()` |
+| Classic vertical louver value `f_dir_ud=C` | What it stands for. `getState` reports `null`. | `ClassicDaikinClient.command()` |
+| Classic schedule demand mode (`mode=1`) | The full format of the weekly table it needs (`moc`..`suc`, `<day><n>_en`/`_t`/`_p`). | `ClassicDaikinClient.command()` |
+| Classic special mode `spmode_kind=4` (heat plus) | Which units take it. | `ClassicDaikinClient.command()` |
+| Timers, weekly programs, schedule timers (`/aircon/get_timer`, `set_timer`, `get_program`, `set_program`, `get_scdltimer_info`, `get_scdltimer_body`, `set_scdltimer_info`, `set_scdltimer_body`) | Their parameters. | `ClassicDaikinClient.command()` |
+| Classic setting reads: `/aircon/get_demand_control`, `/aircon/get_price`, `/aircon/get_target`, `/common/get_holiday` | The reply fields. | `ClassicDaikinClient.command()` |
+| Classic notifications, clock and account: `/common/get_notify`, `set_notify`, `set_push_notice`, `set_timezone`, `notify_date_time`, `set_account` | Their parameters. | `ClassicDaikinClient.command()` |
+| Classic network: `/common/get_network_setting`, `set_network_setting`, `start_wifi_scan`, `get_wifi_scan_result`, `start_wifi_connection`, `permit_wifi_connection`, `set_lpw` | Their parameters. | `ClassicDaikinClient.command()` |
+| Classic firmware update: a POST to `/dkac/system/fwupdate` | The format of the upload. | Not reachable |
+
+## Not modelled
+
+These values are known, but the package's types don't represent them yet:
+
+| Value | What `getState` reports instead |
+| --- | --- |
+| Humidify mode (classic `HUM`, DSIOT `0800`) and laundry mode (classic `LND`) | `mode: "auto"`. `setState` keeps the mode unless the control sets one, and on a DSIOT adapter writes power alone while it is kept. |
+| DSIOT vertical louver values other than stop, the first five fixed positions, swing, auto, natural wind and floor warming | `verticalPosition: null` |
+| DSIOT laundry mode (`dgc_status.e_1002.e_3003.p_25` = `01`) | The mode in `dgc_status.e_1002.e_3001.p_01` |
+| Classic `f_dir=6` (heat with the special air outlet) | `swingMode: "off"` |
+| Japanese units (`reg=jp`), which follow separate rules for limits, humidity and fan, and take a humidity percentage | The rules for other regions |
+
+These adapter codes pass through a model unchanged, because what each one
+stands for is not known:
+
+| Model field | Holds |
+| --- | --- |
+| `DeviceMetadata.icon` | The `icon` that classic `/common/set_icon` takes |
+| `DaikinCapabilities.model` | The classic `model` field, or DSIOT `dgc_status.e_1002.e_A001.p_0D`, such as `0ABB` |

package/dist/authentication.d.ts

@@ -0,0 +1,24 @@
+/** `DaikinTransport.send` calls both methods on every request and adds what
+ * they return. */
+export interface DaikinAuthentication {
+    headers(): Record<string, string> | Promise<Record<string, string>>;
+    /** Replaces a request parameter of the same name. */
+    query(): Record<string, string> | Promise<Record<string, string>>;
+}
+/** Classic adapter that requires the local password: sent as
+ * `?lpw=<value>`. */
+export declare class ClassicLocalPasswordAuthentication implements DaikinAuthentication {
+    private readonly localPassword;
+    constructor(localPassword: string);
+    headers(): Record<string, string>;
+    query(): Record<string, string>;
+}
+/** DSIOT adapter that requires the local password: sent as
+ * `Authorization: Basic <lpw>`. */
+export declare class DsiotLocalPasswordAuthentication implements DaikinAuthentication {
+    private readonly localPassword;
+    constructor(localPassword: string);
+    headers(): Record<string, string>;
+    query(): Record<string, string>;
+}
+//# sourceMappingURL=authentication.d.ts.map

package/dist/authentication.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"authentication.d.ts","sourceRoot":"","sources":["../src/authentication.ts"],"names":[],"mappings":"AAgBA;kBACkB;AAClB,MAAM,WAAW,oBAAoB;IACnC,OAAO,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACpE,qDAAqD;IACrD,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CACnE;AAED;qBACqB;AACrB,qBAAa,kCACX,YAAW,oBAAoB;IAEnB,OAAO,CAAC,QAAQ,CAAC,aAAa;IAA1C,YAA6B,aAAa,EAAE,MAAM,EAAI;IAEtD,OAAO,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAEhC;IAED,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAE9B;CACF;AAED;mCACmC;AACnC,qBAAa,gCAAiC,YAAW,oBAAoB;IAC/D,OAAO,CAAC,QAAQ,CAAC,aAAa;IAA1C,YAA6B,aAAa,EAAE,MAAM,EAAI;IAEtD,OAAO,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAEhC;IAED,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAE9B;CACF"}

package/dist/authentication.js

@@ -0,0 +1,30 @@
+import { encodeClassicLocalPassword, encodeDsiotLocalPassword, } from "./codecs/credentials.js";
+/** Classic adapter that requires the local password: sent as
+ * `?lpw=<value>`. */
+export class ClassicLocalPasswordAuthentication {
+    localPassword;
+    constructor(localPassword) {
+        this.localPassword = localPassword;
+    }
+    headers() {
+        return {};
+    }
+    query() {
+        return encodeClassicLocalPassword(this.localPassword);
+    }
+}
+/** DSIOT adapter that requires the local password: sent as
+ * `Authorization: Basic <lpw>`. */
+export class DsiotLocalPasswordAuthentication {
+    localPassword;
+    constructor(localPassword) {
+        this.localPassword = localPassword;
+    }
+    headers() {
+        return encodeDsiotLocalPassword(this.localPassword);
+    }
+    query() {
+        return {};
+    }
+}
+//# sourceMappingURL=authentication.js.map

package/dist/authentication.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"authentication.js","sourceRoot":"","sources":["../src/authentication.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,0BAA0B,EAC1B,wBAAwB,GACzB,MAAM,yBAAyB,CAAC;AAqBjC;qBACqB;AACrB,MAAM,OAAO,kCAAkC;IAGhB,aAAa;IAA1C,YAA6B,aAAqB;6BAArB,aAAa;IAAW,CAAC;IAEtD,OAAO;QACL,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,KAAK;QACH,OAAO,0BAA0B,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;IACxD,CAAC;CACF;AAED;mCACmC;AACnC,MAAM,OAAO,gCAAgC;IACd,aAAa;IAA1C,YAA6B,aAAqB;6BAArB,aAAa;IAAW,CAAC;IAEtD,OAAO;QACL,OAAO,wBAAwB,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;IACtD,CAAC;IAED,KAAK;QACH,OAAO,EAAE,CAAC;IACZ,CAAC;CACF"}

package/dist/clients/classic.d.ts

@@ -0,0 +1,53 @@
+import type { DaikinCapabilities } from "../models/capabilities.js";
+import type { DemandControl, DeviceMetadata, SpecialMode, TerminalScope } from "../models/extendedControl.js";
+import type { DaikinControl, DaikinSensors, DaikinState } from "../models/state.js";
+import { type DaikinRequestOptions, type DaikinRetryOptions, type DaikinTransport } from "../transport.js";
+import type { DaikinClient } from "./client.js";
+/** Classic CGI adapter (BRP069-style). Reads and writes are HTTP GET with query
+ * parameters; replies are `key=value,key=value`. */
+export declare class ClassicDaikinClient implements DaikinClient {
+    private readonly transport;
+    private readonly retryOptions?;
+    private capabilityFields;
+    /** `close` closes `transport`, so give each client a transport of its own. */
+    constructor(transport: DaikinTransport, retryOptions?: DaikinRetryOptions | undefined);
+    close(): Promise<void>;
+    getCapabilities(): Promise<DaikinCapabilities>;
+    getState(): Promise<DaikinState>;
+    setState(control: DaikinControl): Promise<void>;
+    getSensors(): Promise<DaikinSensors>;
+    /** Adapter status LED on/off (`set_led`). */
+    setLed(on: boolean): Promise<void>;
+    /** Holiday / away mode (`set_holiday`). */
+    setHolidayMode(enabled: boolean): Promise<void>;
+    /** Demand control — cap the unit's power draw (`set_demand_control`). */
+    setDemandControl(demand: DemandControl): Promise<void>;
+    /** Powerful, econo or streamer (`set_special_mode`). */
+    setSpecialMode(mode: SpecialMode, enabled: boolean): Promise<void>;
+    /** Whether the unit can be operated from outside the home network
+     * (`set_remote_method`). */
+    setOutOfHomeAccess(enabled: boolean): Promise<void>;
+    /** Electricity price per kWh for the consumption estimates (`set_price`),
+     * to two decimal places. */
+    setEnergyPrice(price: number): Promise<void>;
+    /** Energy target for the "target" feature (`set_target`). */
+    setEnergyTarget(target: number): Promise<void>;
+    /** Name / icon / group metadata (`set_name` etc.). */
+    setMetadata(metadata: DeviceMetadata): Promise<void>;
+    /** Register this client's uuid with an adapter whose
+     * `requiresRegistration` is true, using the KEY printed on the adapter's
+     * label (`register_terminal`). Once per uuid; the adapter remembers it. */
+    registerTerminal(key: string): Promise<void>;
+    /** Unregister terminals (`unregister_terminal`): this uuid, every other
+     * uuid, or all of them. */
+    unregisterTerminal(scope?: TerminalScope): Promise<void>;
+    /** Reboot the adapter (`reboot`). */
+    reboot(): Promise<void>;
+    /** Calls any classic CGI endpoint with query parameters and returns the reply's
+     * `key=value` fields. It reaches the controls without a typed method:
+     * timers, schedules, programs, network, credentials and firmware. It throws
+     * a `DaikinError` when the reply's `ret` is not `OK`. */
+    command(path: string, parameters?: Record<string, string>, { retry }?: DaikinRequestOptions): Promise<Record<string, string>>;
+    private readCapabilityFields;
+}
+//# sourceMappingURL=classic.d.ts.map

package/dist/clients/classic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"classic.d.ts","sourceRoot":"","sources":["../../src/clients/classic.ts"],"names":[],"mappings":"AA2BA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AACpE,OAAO,KAAK,EACV,aAAa,EACb,cAAc,EACd,WAAW,EACX,aAAa,EACd,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EACV,aAAa,EACb,aAAa,EACb,WAAW,EACZ,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,KAAK,oBAAoB,EACzB,KAAK,kBAAkB,EACvB,KAAK,eAAe,EAErB,MAAM,iBAAiB,CAAC;AACzB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AA0BhD;oDACoD;AACpD,qBAAa,mBAAoB,YAAW,YAAY;IAOpD,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAC;IALhC,OAAO,CAAC,gBAAgB,CAA8C;IAEtE,8EAA8E;IAC9E,YACmB,SAAS,EAAE,eAAe,EAC1B,YAAY,CAAC,EAAE,kBAAkB,YAAA,EAChD;IAEJ,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAErB;IAEK,eAAe,IAAI,OAAO,CAAC,kBAAkB,CAAC,CAEnD;IAEK,QAAQ,IAAI,OAAO,CAAC,WAAW,CAAC,CAErC;IAEK,QAAQ,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAOpD;IAEK,UAAU,IAAI,OAAO,CAAC,aAAa,CAAC,CAIzC;IAKD,6CAA6C;IACvC,MAAM,CAAC,EAAE,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAEvC;IAED,2CAA2C;IACrC,cAAc,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAKpD;IAED,yEAAyE;IACnE,gBAAgB,CAAC,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAK3D;IAED,wDAAwD;IAClD,cAAc,CAAC,IAAI,EAAE,WAAW,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAKvE;IAED;gCAC4B;IACtB,kBAAkB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAMxD;IAED;gCAC4B;IACtB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAKjD;IAED,6DAA6D;IACvD,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAKnD;IAED,sDAAsD;IAChD,WAAW,CAAC,QAAQ,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAmBzD;IAED;;+EAE2E;IACrE,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAKjD;IAED;+BAC2B;IACrB,kBAAkB,CAAC,KAAK,GAAE,aAAsB,GAAG,OAAO,CAAC,IAAI,CAAC,CAKrE;IAED,qCAAqC;IAC/B,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,CAE5B;IAED;;;6DAGyD;IACnD,OAAO,CACX,IAAI,EAAE,MAAM,EACZ,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EACnC,EAAE,KAAY,EAAE,GAAE,oBAAyB,GAC1C,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAYjC;IAED,OAAO,CAAC,oBAAoB;CAY7B"}

package/dist/clients/classic.js

@@ -0,0 +1,142 @@
+import { mergeClassicCapabilityFields, parseClassicCapabilities, } from "../codecs/classic/capabilities.js";
+import { applyClassicOutOfHomeAccess, encodeClassicDemandControl, encodeClassicEnergyPrice, encodeClassicEnergyTarget, encodeClassicGroup, encodeClassicHolidayMode, encodeClassicIcon, encodeClassicLed, encodeClassicName, encodeClassicSpecialMode, encodeClassicTerminalKey, encodeClassicTerminalScope, } from "../codecs/classic/extendedControl.js";
+import { assertClassicOk, parseClassicKeyValue, } from "../codecs/classic/keyValue.js";
+import { applyClassicControl, parseClassicSensors, parseClassicState, } from "../codecs/classic/state.js";
+import { withRetry, } from "../transport.js";
+// Classic CGI endpoints (BRP069-style). Reads and writes are both HTTP GET with
+// query parameters; the reply is `key=value,key=value`.
+const CLASSIC_ROUTES = {
+    basicInfo: "/common/basic_info",
+    getModelInfo: "/aircon/get_model_info",
+    getControlInfo: "/aircon/get_control_info",
+    setControlInfo: "/aircon/set_control_info",
+    getSensorInfo: "/aircon/get_sensor_info",
+    setSpecialMode: "/aircon/set_special_mode",
+    setDemandControl: "/aircon/set_demand_control",
+    setPrice: "/aircon/set_price",
+    setTarget: "/aircon/set_target",
+    setLed: "/common/set_led",
+    setHoliday: "/common/set_holiday",
+    setName: "/common/set_name",
+    setIcon: "/common/set_icon",
+    setGroup: "/common/set_group",
+    getRemoteMethod: "/common/get_remote_method",
+    setRemoteMethod: "/common/set_remote_method",
+    reboot: "/common/reboot",
+    registerTerminal: "/common/register_terminal",
+    unregisterTerminal: "/common/unregister_terminal",
+};
+/** Classic CGI adapter (BRP069-style). Reads and writes are HTTP GET with query
+ * parameters; replies are `key=value,key=value`. */
+export class ClassicDaikinClient {
+    transport;
+    retryOptions;
+    // A unit's capabilities don't change, and `setState` needs them, so they are
+    // read once.
+    capabilityFields;
+    /** `close` closes `transport`, so give each client a transport of its own. */
+    constructor(transport, retryOptions) {
+        this.transport = transport;
+        this.retryOptions = retryOptions;
+    }
+    close() {
+        return this.transport.close();
+    }
+    async getCapabilities() {
+        return parseClassicCapabilities(await this.readCapabilityFields());
+    }
+    async getState() {
+        return parseClassicState(await this.command(CLASSIC_ROUTES.getControlInfo));
+    }
+    async setState(control) {
+        const capabilityFields = await this.readCapabilityFields();
+        const current = await this.command(CLASSIC_ROUTES.getControlInfo);
+        await this.command(CLASSIC_ROUTES.setControlInfo, applyClassicControl(current, control, capabilityFields));
+    }
+    async getSensors() {
+        return parseClassicSensors(await this.command(CLASSIC_ROUTES.getSensorInfo));
+    }
+    // --- extended controls ---------------------------------------------------
+    // Each maps to its own endpoint (not control_info).
+    /** Adapter status LED on/off (`set_led`). */
+    async setLed(on) {
+        await this.command(CLASSIC_ROUTES.setLed, encodeClassicLed(on));
+    }
+    /** Holiday / away mode (`set_holiday`). */
+    async setHolidayMode(enabled) {
+        await this.command(CLASSIC_ROUTES.setHoliday, encodeClassicHolidayMode(enabled));
+    }
+    /** Demand control — cap the unit's power draw (`set_demand_control`). */
+    async setDemandControl(demand) {
+        await this.command(CLASSIC_ROUTES.setDemandControl, encodeClassicDemandControl(demand));
+    }
+    /** Powerful, econo or streamer (`set_special_mode`). */
+    async setSpecialMode(mode, enabled) {
+        await this.command(CLASSIC_ROUTES.setSpecialMode, encodeClassicSpecialMode(mode, enabled));
+    }
+    /** Whether the unit can be operated from outside the home network
+     * (`set_remote_method`). */
+    async setOutOfHomeAccess(enabled) {
+        const current = await this.command(CLASSIC_ROUTES.getRemoteMethod);
+        await this.command(CLASSIC_ROUTES.setRemoteMethod, applyClassicOutOfHomeAccess(current, enabled));
+    }
+    /** Electricity price per kWh for the consumption estimates (`set_price`),
+     * to two decimal places. */
+    async setEnergyPrice(price) {
+        await this.command(CLASSIC_ROUTES.setPrice, encodeClassicEnergyPrice(price));
+    }
+    /** Energy target for the "target" feature (`set_target`). */
+    async setEnergyTarget(target) {
+        await this.command(CLASSIC_ROUTES.setTarget, encodeClassicEnergyTarget(target));
+    }
+    /** Name / icon / group metadata (`set_name` etc.). */
+    async setMetadata(metadata) {
+        if (metadata.name !== undefined) {
+            await this.command(CLASSIC_ROUTES.setName, encodeClassicName(metadata.name));
+        }
+        if (metadata.icon !== undefined) {
+            await this.command(CLASSIC_ROUTES.setIcon, encodeClassicIcon(metadata.icon));
+        }
+        if (metadata.group !== undefined) {
+            await this.command(CLASSIC_ROUTES.setGroup, encodeClassicGroup(metadata.group));
+        }
+    }
+    /** Register this client's uuid with an adapter whose
+     * `requiresRegistration` is true, using the KEY printed on the adapter's
+     * label (`register_terminal`). Once per uuid; the adapter remembers it. */
+    async registerTerminal(key) {
+        await this.command(CLASSIC_ROUTES.registerTerminal, encodeClassicTerminalKey(key));
+    }
+    /** Unregister terminals (`unregister_terminal`): this uuid, every other
+     * uuid, or all of them. */
+    async unregisterTerminal(scope = "self") {
+        await this.command(CLASSIC_ROUTES.unregisterTerminal, encodeClassicTerminalScope(scope));
+    }
+    /** Reboot the adapter (`reboot`). */
+    async reboot() {
+        await this.command(CLASSIC_ROUTES.reboot, undefined, { retry: false });
+    }
+    /** Calls any classic CGI endpoint with query parameters and returns the reply's
+     * `key=value` fields. It reaches the controls without a typed method:
+     * timers, schedules, programs, network, credentials and firmware. It throws
+     * a `DaikinError` when the reply's `ret` is not `OK`. */
+    async command(path, parameters, { retry = true } = {}) {
+        const send = () => this.transport.send({
+            method: "GET",
+            path,
+            ...(parameters ? { query: parameters } : {}),
+        });
+        const fields = parseClassicKeyValue(await (retry ? withRetry(send, this.retryOptions) : send()));
+        assertClassicOk(fields);
+        return fields;
+    }
+    readCapabilityFields() {
+        this.capabilityFields ??= (async () => mergeClassicCapabilityFields(await this.command(CLASSIC_ROUTES.basicInfo), await this.command(CLASSIC_ROUTES.getModelInfo)))();
+        // A failed read is not cached, so the next call tries again.
+        this.capabilityFields.catch(() => {
+            this.capabilityFields = undefined;
+        });
+        return this.capabilityFields;
+    }
+}
+//# sourceMappingURL=classic.js.map

package/dist/clients/classic.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"classic.js","sourceRoot":"","sources":["../../src/clients/classic.ts"],"names":[],"mappings":"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"}

package/dist/clients/client.d.ts

@@ -0,0 +1,21 @@
+import type { DaikinCapabilities } from "../models/capabilities.js";
+import type { DaikinControl, DaikinSensors, DaikinState } from "../models/state.js";
+/** The controls every adapter offers, whatever its wire protocol or
+ * authentication. `createDaikinClient` picks the implementation, so a caller
+ * needs the concrete class only for what one protocol adds, such as
+ * `ClassicDaikinClient.registerTerminal`. Every method rejects with a
+ * `DaikinError` when its request fails. */
+export interface DaikinClient {
+    /** The unit's supported features. */
+    getCapabilities(): Promise<DaikinCapabilities>;
+    /** Current controllable state. */
+    getState(): Promise<DaikinState>;
+    /** Change part of the state. The client reads the current state, overlays the
+     * control, and writes the whole thing back. */
+    setState(control: DaikinControl): Promise<void>;
+    /** Read-only temperature / humidity readings. */
+    getSensors(): Promise<DaikinSensors>;
+    /** Close the connection to the adapter. */
+    close(): Promise<void>;
+}
+//# sourceMappingURL=client.d.ts.map