daikin-local-control 0.4.0 → 0.5.0

package/DESIGN.md

@@ -53,6 +53,46 @@ the read. A `DaikinState` holds the current mode's values alone: it has neither
 the values a classic adapter remembers for the other modes nor the `md` of a
 DSIOT leaf, so the client would still need the reply.
 
+## Discovery
+
+`discoverDevices` sends its probes from the first free UDP port from 30000 to
+30050. An adapter answers the port a probe came from, so a reply reaches the
+call that sent the probe.
+
+Rejected: port 30000 alone, bound with `reuseAddr`.
+
+- Two calls at the same time both bound the port, and each reply reached one
+  of the two sockets alone. One call resolved with every adapter and the other
+  with none, and neither rejected.
+
+`discoverDevices` asks each adapter that replies as a classic one, over HTTP,
+whether it is an Airbase adapter: `isAirbaseAdapter` takes HTTP 404 at
+`/common/basic_info` with `ret=OK` at `/skyfi/common/basic_info` for one.
+
+Rejected: the protocol from the reply alone.
+
+- An Airbase adapter reports `type=aircon` as a classic adapter does, and no
+  field of the reply is known to differ. Discovery reported it as `classic`,
+  and it answered HTTP 404 to every request of the client built from that.
+
+Rejected: asking in `createDaikinClient`, for a device written by hand as
+well.
+
+- `createDaikinClient` returns a client at once and sends nothing. Asking
+  there would make it asynchronous for every caller, to settle what a caller
+  who writes a device by hand already knows.
+
+`discoverDevices` resolves with the adapters of air conditioners alone:
+`isAirConditioner` passes a reply whose `type` is `aircon`, or `GPF` with a
+`cdev` that is not an air cleaner's.
+
+Rejected: a device for every adapter that answers.
+
+- The adapter of an air cleaner, a water heater, a floor heater or a
+  circulator answers the probe as well. `parseDevice` read each as a classic
+  air conditioner, a `DaikinDevice` had nothing to tell them apart by, and no
+  method of the client built from one worked.
+
 ## Capabilities
 
 `DaikinCapabilities` lists what a unit accepts in the vocabulary of `DaikinState`:
@@ -154,8 +194,8 @@ Rejected: one list for the whole unit.
 
 ## Simulators
 
-`startClassicSimulator` and `startDsiotSimulator` each start an adapter as a
-server. A simulator shares the codecs' tables, `src/codecs/*/tables.ts`, and
+`startClassicSimulator`, `startDsiotSimulator` and `startAirbaseSimulator`
+each start an adapter as a server. A simulator shares the codecs' tables, `src/codecs/*/tables.ts`, and
 none of their functions. A table holds what an adapter calls a thing: its
 field and leaf names, and the code for each value. A function does something
 with it: a codec parses a reply and builds a request, and a simulator answers
@@ -198,8 +238,11 @@ reply.
 - A caller had to know the adapter's encodings to start a unit in a state: a
   DSIOT setpoint of 24 °C is the leaf value `3000`.
 
-A simulator takes what the unit has as a `DaikinSimulatorUnit`, which says it
-in terms both protocols have flags for: `coolingOnly`, `swing`, `fan`.
+A classic or a DSIOT simulator takes what the unit has as a
+`DaikinSimulatorUnit`, which says it in terms both protocols have flags for:
+`coolingOnly`, `swing`, `fan`. An Airbase simulator takes an
+`AirbaseSimulatorUnit` of its own: an Airbase unit has zones and airside, and
+neither a cooling-only kind nor a special mode.
 
 Rejected: taking a `DaikinCapabilities`.
 

package/README.md

@@ -1,26 +1,32 @@
 # daikin-local-control
 
 [![npm version](https://img.shields.io/npm/v/daikin-local-control)](https://www.npmjs.com/package/daikin-local-control)
+[![npm downloads](https://img.shields.io/npm/dm/daikin-local-control)](https://www.npmjs.com/package/daikin-local-control)
 [![CI](https://github.com/cheziyi/daikin-local-control/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/cheziyi/daikin-local-control/actions/workflows/ci.yml?query=branch%3Amain)
 [![Node version](https://img.shields.io/node/v/daikin-local-control)](package.json)
+[![Types](https://img.shields.io/npm/types/daikin-local-control)](package.json)
 [![License](https://img.shields.io/npm/l/daikin-local-control)](LICENSE)
+[![Checked with Biome](https://img.shields.io/badge/Checked_with-Biome-60a5fa?style=flat&logo=biome)](https://biomejs.dev)
 
 A TypeScript and Node.js client for controlling Daikin air conditioners **over
 the local network** (LAN), through their Wi-Fi adapters and 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).
+dependency. It implements the local-control protocols of the **DAIKIN Mobile
+Controller**, **Daikin Airbase** and **ONECTA** apps, so it works with the units
+and Wi-Fi adapters those apps support — split / multi-split, SkyAir and ducted
+units fitted with adapters such as the BRP072A42, BRP072C42, BRP084, BRP069 and
+BRP15B61 — in the [markets where those apps are used](#coverage--limitations).
 
-Daikin Wi-Fi adapters come in two generations, and the package has a client for
-each:
+Daikin Wi-Fi adapters speak one of three protocols, 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, louver positions and special modes;
   [UNSUPPORTED.md](UNSUPPORTED.md) lists what is not mapped yet.
+- **`AirbaseDaikinClient`** — Airbase adapters (BRP15B61) on ducted units.
+  Power, mode, setpoint, fan and direction, plus [zones](#airbase), fan auto
+  and airside.
 
 You normally don't pick one yourself: `createDaikinClient` chooses the right
 client for each discovered device.
@@ -47,9 +53,9 @@ 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).
+// 2. Build the right client: createDaikinClient picks the classic, the DSIOT
+//    or the Airbase 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,
@@ -73,17 +79,19 @@ await client.close();
 
 ### Discovery
 
-`discoverDevices()` resolves with one `DaikinDevice` for each adapter that
-answered, and with an empty array when none did. Each carries the adapter's
-`macAddress`, such as `A4:08:EA:CC:91:D4`, and `firmwareVersion`, such as
-`1.2.51`, when the adapter reports them: key a stored device on `macAddress`,
-because `host` changes when the adapter is given a new address.
+`discoverDevices()` resolves with one `DaikinDevice` for each air conditioner's
+adapter that answered, and with an empty array when none did. Each carries the
+adapter's `macAddress`, such as `A4:08:EA:CC:91:D4`, and `firmwareVersion`,
+such as `1.2.51`, when the adapter reports them: key a stored device on
+`macAddress`, because `host` changes when the adapter is given a new address.
 
 | 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 |
+| Keeps the adapters of air conditioners alone | It leaves out the adapter of an air cleaner, a water heater or another appliance, which answers the same broadcast |
+| Asks each classic adapter over HTTP whether it is an Airbase adapter, which replies to the broadcast as a classic one does | It resolves later than `timeoutInMs` while an adapter is slow to answer, by 3000 ms at most for each request after up to 750 ms of retrying a dropped connection, and reports as `classic` one that does not answer. An Airbase device requires no registration and no child lock code, whatever the adapter's reply says |
+| Binds the first free UDP port from 30000 to 30050 | Calls made at the same time each get every reply. It rejects with the socket's error when none of the ports is free, or when the socket fails |
 
 Write the device by hand when you already know its address, or when discovery
 cannot reach it:
@@ -98,8 +106,13 @@ const client = createDaikinClient(device, { terminalUuid: savedUuid });
 A device written by hand has no `name`, `macAddress` or `firmwareVersion`: read
 them from the adapter with `await client.getDeviceInfo()`.
 
-Set `protocol` to `dsiot` for a BRP084 and to `classic` for every other
-adapter. A device without flags is an adapter that requires neither
+To tell an Airbase adapter from a classic one by its address, request
+`/common/basic_info`: an Airbase adapter answers HTTP 404 there, and `ret=OK`
+at `/skyfi/common/basic_info`.
+
+Set `protocol` to `dsiot` for a BRP084, to `airbase` for a BRP15B61 and to
+`classic` for every other adapter: `createDaikinClient()` goes by it and asks
+the adapter nothing. 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
@@ -109,7 +122,9 @@ for you.
 ### Credentials
 
 An adapter can need up to three things. Discovery tells you which ones apply
-(`device.requiresRegistration`, `device.requiresLocalPassword`).
+(`device.requiresRegistration`, `device.requiresLocalPassword`). An Airbase
+adapter takes none of them: `createDaikinClient()` still takes a
+`terminalUuid`, and sends it nothing of the three.
 
 **Terminal uuid (always).** It identifies your app to the adapter. Pass 32
 lowercase hexadecimal digits, a UUID without its dashes: `createDaikinClient()`
@@ -128,8 +143,8 @@ const savedUuid =
 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.
+Each uuid is registered separately, so an adapter already set up in a Daikin
+app still needs registering here.
 
 ```ts
 import { ClassicDaikinClient } from "daikin-local-control";
@@ -149,8 +164,8 @@ Some of these adapters also switch to HTTPS (`device.usesHttps`); see
 
 **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
+in the Daikin app the adapter was set up with. 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
@@ -203,11 +218,16 @@ given, whether or not the unit lists 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 |
+| `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. On an Airbase adapter, always |
+
+An Airbase adapter also drops every `targetHumidity`, and a
+`targetTemperatureInC` in `fan` as well as in `dehumidify`.
 
 `setState()` takes no `specialModes`: turn one on or off with
 `setSpecialMode()`, which sends a request of its own. Check the mode against
 `getCapabilities().specialModes` first: the client sends any mode as given.
+An Airbase adapter has no request for one, so `AirbaseDaikinClient` rejects
+with a `DaikinError` whose `httpStatusCode` is 501.
 
 ```ts
 await client.setSpecialMode("powerful", true);
@@ -271,6 +291,43 @@ what is not known about each.
 `DsiotDaikinClient` has `reboot()` and the raw `multireqGet` / `multireqUpdate`
 hatches for any `dgc_status` leaf.
 
+### Airbase
+
+`AirbaseDaikinClient` adds the controls a ducted unit has. Narrow to the
+concrete class to reach them:
+
+```ts
+import { AirbaseDaikinClient } from "daikin-local-control";
+
+if (client instanceof AirbaseDaikinClient) {
+  const zones = await client.getZones(); // [{ name: "Living", enabled: true }, ...]
+  await client.setZone(1, true); // open the second zone
+
+  if ((await client.getFanAuto()) !== null) {
+    await client.setFanAuto(true);
+  }
+  if ((await client.getAirside()) !== null) {
+    await client.setAirside(true);
+  }
+
+  // Any other endpoint, by its path below /skyfi.
+  const holiday = await client.command("/common/get_holiday");
+}
+```
+
+| Method | Does |
+| --- | --- |
+| `getZones()` | Resolves with `{ name, enabled }` for each zone, in the unit's order, and with an empty array on a unit without zones |
+| `setZone(index, enabled)` | Opens or closes the zone at that place in `getZones()`, counted from 0 |
+| `getFanAuto()`, `getAirside()` | Resolve with `true` or `false`, or `null` on a unit that does not take the setting |
+| `setFanAuto(enabled)` | Lets the unit pick the fan speed itself, up to the `fanSpeed` that is set. It switches airside off |
+| `setAirside(enabled)` | Switches airside on or off. Switching it on switches fan auto off and sets `fanSpeed` to `level1` |
+
+A `fanSpeed` in `setState()` switches airside off and keeps fan auto.
+
+Only a unit with zones takes fan auto and airside, and it takes no `auto` fan
+speed and no `swingMode`: `getCapabilities()` lists what a unit takes.
+
 ### Errors and retries
 
 A client method that fails rejects with a `DaikinError`; branch on
@@ -282,13 +339,15 @@ A client method that fails rejects with a `DaikinError`; branch on
 | 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 |
+| 501 | `AirbaseDaikinClient.setSpecialMode()`: an Airbase adapter has no request for a special mode |
 | Any other | The adapter's own HTTP status, such as 403 |
 
-Three failures are not a `DaikinError`: `discoverDevices()` rejects with the
+Four failures are not a `DaikinError`: `discoverDevices()` rejects with the
 socket's error, `createDaikinClient()` throws an `Error` for a
-[terminal uuid](#credentials) in the wrong form, and `multireqUpdate()` throws
+[terminal uuid](#credentials) in the wrong form, `multireqUpdate()` throws
 an `Error` for a path that names a resource without a leaf, such as
-`dgc_status`.
+`dgc_status`, and `setZone()` rejects with an `Error` for an index the unit
+has no zone at.
 
 Only a `DaikinConnectionError` is retried, up to five times by default.
 [DESIGN.md](DESIGN.md#retries) says why.
@@ -330,9 +389,10 @@ await simulator.stop();
 ```
 
 `startDsiotSimulator()` starts a DSIOT adapter and takes the same options:
-pass `protocol: "dsiot"` to `createDaikinClient`. A simulator speaks plain
-HTTP on a free port of `127.0.0.1`, which nothing outside the machine
-reaches.
+pass `protocol: "dsiot"` to `createDaikinClient`.
+`startAirbaseSimulator()` starts an [Airbase adapter](#airbase-simulator):
+pass `protocol: "airbase"`. A simulator speaks plain HTTP on a free port of
+`127.0.0.1`, which nothing outside the machine reaches.
 
 Describe the adapter and its unit in the types the clients resolve with:
 
@@ -356,6 +416,40 @@ Describe the adapter and its unit in the types the clients resolve with:
 `setState()` throws an `Error` for a field the unit has nothing to hold, such
 as a `verticalPosition` on a unit without fixed louver positions.
 
+#### Airbase simulator
+
+`startAirbaseSimulator()` takes `deviceInfo`, `state` and `sensors` as the
+other two do, and a `unit` of its own. It reports no humidity unless
+`sensors` gives one, and its `setState()` throws an `Error` for a
+`targetHumidity`, a louver position or a special mode.
+
+```ts
+import { startAirbaseSimulator } from "daikin-local-control/simulators";
+
+const simulator = await startAirbaseSimulator({
+  unit: { zones: ["Living", "Bedrooms"], airside: true },
+  state: { power: true, fanSpeed: "level3" },
+});
+
+simulator.setZone(1, false); // someone closes a zone on the wall controller
+simulator.controlInfo.f_auto = "1"; // and switches fan auto on
+```
+
+| `unit` field | Holds | Defaults to |
+| --- | --- | --- |
+| `zones` | The names of the unit's zones, each open at the start | None: a unit without zones |
+| `auto`, `dehumidify` | `false` for a unit that does not offer the mode | `true` |
+| `fan` | `false` for a unit whose fan speed cannot be set | `true` |
+| `fanLevels` | 2 or 3 fan levels | 3 |
+| `airside` | `true` for a unit with zones that takes airside | `false` |
+| `swing` | `false` for a unit without zones that takes no direction | `true` |
+| `coolTemperaturesInC`, `heatTemperaturesInC` | `{ min, max }`, in whole degrees | None reported, so 18 to 32 and 10 to 30 |
+
+A unit with zones takes fan auto, and no `auto` fan speed and no direction.
+It answers HTTP 404 to a path outside `/skyfi`, as an Airbase adapter does,
+so `discoverDevices()` reports it as `airbase` when it is started with
+`answersDiscovery`.
+
 | To | Do |
 | --- | --- |
 | Check what the unit holds | Call `getState()` on a client |
@@ -379,8 +473,9 @@ simulator with `answersDiscovery` rejects with the socket's error.
 For anything the options above do not cover, such as humidity settings or
 fixed louver positions, set the adapter's own fields. A classic simulator
 takes `basicInfo`, `modelInfo`, `controlInfo` and `sensorInfo`, the fields of
-each reply, and holds them under the same names. A DSIOT simulator takes
-`leaves`, and holds each leaf by its address. A field given this way replaces
+each reply, and holds them under the same names. An Airbase simulator takes
+those four and `zoneSetting`. A DSIOT simulator takes `leaves`, and holds each
+leaf by its address. A field given this way replaces
 what `unit` sets, and `state` and `sensors` replace it in turn. The package
 root exports the adapter's codes as tables, such as `CLASSIC_FAN_SPEED_CODES`
 and `DSIOT_PATHS`.
@@ -411,20 +506,33 @@ clients' codecs, and why no more.
 
 ## 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).
+It supports the Wi-Fi adapters of three apps, in the markets where each is
+used, so it is **not valid for every Daikin region or app**.
+
+| App | Markets | Adapters | Client |
+| --- | --- | --- | --- |
+| DAIKIN Mobile Controller | Thailand, Singapore, the Philippines, Hong Kong, Taiwan, Australia, New Zealand | BRP072A42, BRP072C42, BRP069 | `ClassicDaikinClient` |
+| DAIKIN Mobile Controller | The same | BRP084 | `DsiotDaikinClient` |
+| Daikin Airbase | Australia | BRP15B61, on a ducted unit | `AirbaseDaikinClient` |
+| ONECTA, once Daikin Online Controller | Europe | BRP069A and BRP069B series | `ClassicDaikinClient` |
+
+Each app may be available in more countries than the table lists: if your
+local Daikin site points you to one of the three, this package should apply.
+
+Three limits apply, and [UNSUPPORTED.md](UNSUPPORTED.md) says what is not known
+about each:
+
+- **Europe**: power, mode, setpoint, fan, swing and special modes go to a
+  classic adapter there as they do elsewhere. `getCapabilities()` follows the
+  rules of the other markets, and which adapters there speak HTTPS is not
+  known.
+- **A DSIOT adapter in Europe** (BRP069C series) is not covered: it may not
+  answer on the LAN until it is switched on.
+- **An Airbase adapter** is told from a classic one by how it answers over
+  HTTP: no field of its discovery reply is known to differ.
+
+Units sold for other apps likely use a different protocol, e.g. 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

package/UNSUPPORTED.md

@@ -31,6 +31,20 @@ To add one, pin down the request and reply first, then delete its row.
 | 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 |
 | A terminal uuid in another form: with dashes, uppercase, or not 32 hexadecimal digits | Whether the adapter accepts it. `createDaikinClient` throws an `Error` for one. | Not reachable |
+| Telling an Airbase adapter from a classic one in a discovery reply | Whether any field of the reply differs: both report `type=aircon`. `discoverDevices` asks the adapter over HTTP instead, and takes HTTP 404 at `/common/basic_info` with `ret=OK` at `/skyfi/common/basic_info` for an Airbase adapter. What a classic adapter answers under `/skyfi` is not known, so it is never asked there. | Set `protocol` on the `DaikinDevice` by hand |
+| An Airbase child lock: `lpw_flag` in its `/common/basic_info` | Whether an Airbase adapter has a child lock code, and how a request would carry one. `discoverDevices` reports `requiresLocalPassword: false` for an Airbase adapter whatever its `lpw_flag`, and `AirbaseDaikinClient` sends no `lpw`. | `AirbaseDaikinClient.command()` |
+| Airbase special modes | Whether a unit takes any, and the request. `getState` reports none, and `AirbaseDaikinClient.setSpecialMode` rejects with status 501. | `AirbaseDaikinClient.command()` |
+| Airbase humidity: `shum`, and `dh1` to `dhh` in `/aircon/get_control_info` | Whether a ducted unit has a humidity setting, and what each field holds. `getState` reports `null`, and `setState` sends `shum` back as the unit holds it and none of the `dh` fields. | `AirbaseDaikinClient.command()` |
+| Airbase energy monitoring and demand control | Which field says a unit has either. `getCapabilities` reports `false` for both. | `AirbaseDaikinClient.command()` |
+| Airbase `f_dir` values 4 and 7 | What each stands for. `getState` reports `swingMode: "off"`. | `AirbaseDaikinClient.command()` |
+| Airbase `bk_auto` and `operate` in `/aircon/get_control_info`, on a unit that reports a `bk_auto` other than its mode while it runs in cool or heat | Which of the two modes such a unit remembers a fan speed for. `setState` writes it to the one `bk_auto` names. | `AirbaseDaikinClient.command()` |
+| Airbase `/aircon/set_control_info` without the memory fields: `dt0` to `dt7`, `dfr1`, `dfr2`, `dfd1`, `dfd2`, `auto1`, `auto2`, `airside1` and `airside2` | Whether the adapter takes it, so `setState` sends each one a control changes. | `AirbaseDaikinClient.command()` |
+| Every other Airbase endpoint: timers, programs, schedules, holiday, demand control, energy history, network and firmware | Their parameters and reply fields. | `AirbaseDaikinClient.command()` |
+| A classic adapter sold in Europe: the capability fields of a unit there (`reg=eu`) | Whether such a unit reports them as a unit in the other markets does. `getCapabilities` reads them by the same rules. | `ClassicDaikinClient.command()` |
+| A classic adapter sold in Europe that reports `adp_kind=3` and `en_secure=1` | Whether it speaks HTTPS, as such an adapter does in the other markets. `discoverDevices` sets `usesHttps` for it. | Set `usesHttps: false` on the `DaikinDevice` |
+| A DSIOT adapter sold in Europe (BRP069C series) | Whether its `dgc_status` leaves hold the values a BRP084 holds. Its `adp_i`, `adp_d` and `dgc_status` resources are read with the same request. | `DsiotDaikinClient.multireqGet()` |
+| A DSIOT adapter that answers `/dsiot/multireq` only once it is switched on, by the UDP datagram `DAIKIN_UDP/debug/en_multireq 1` sent to its port 30050 | Which adapters need it, what one answers to the datagram and to `/dsiot/multireq` before it, and how long it stays on. | Not reachable |
+| An adapter whose discovery reply has a `type` other than `aircon` and `GPF`, such as `common_adp`, or none | Whether any is an air conditioner's. `discoverDevices` leaves it out. | Write the `DaikinDevice` by hand |
 
 ## Not modelled
 
@@ -43,6 +57,9 @@ These values are known, but the package's types don't represent them yet:
 | 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 |
+| Airbase zone temperatures: `lztemp_c` and `lztemp_h` in `/aircon/get_zone_setting`, a setpoint for each zone in cool and in heat | Nothing: `getZones` leaves them out, and `setZone` sends them back as the unit holds them |
+| Airbase fan auto and airside | `fanSpeed` holds `f_rate` alone. `AirbaseDaikinClient.getFanAuto` and `getAirside` report the other two |
+| Airbase modes outside `OperatingMode`, such as `HUM` | `mode: "auto"`. `setState` keeps the mode unless the control sets one |
 
 These adapter codes pass through a model unchanged, because what each one
 stands for is not known:
@@ -54,8 +71,9 @@ stands for is not known:
 
 ## Simulators
 
-`startClassicSimulator` and `startDsiotSimulator` answer HTTP 501 to every
-request this table leaves them without an answer for:
+`startClassicSimulator`, `startDsiotSimulator` and `startAirbaseSimulator`
+answer HTTP 501 to every request this table leaves them without an answer
+for:
 
 | Left out | What is unknown |
 | --- | --- |
@@ -66,6 +84,8 @@ request this table leaves them without an answer for:
 | A `/dsiot/multireq` body that is not JSON, has no `requests`, or carries an `op` other than 2 in a POST and 3 in a PUT | What an adapter answers. |
 | `setState` on a DSIOT simulator with a humidity percentage, or a fixed horizontal louver position: it throws an `Error` | The step a percentage is counted in, and which value each position is. Set the leaf in `leaves`. |
 | HTTPS | The certificate an adapter presents is issued by Daikin's own CA. A simulator started with a `key` reports `adp_kind=4`, an adapter that registers terminals over HTTP. |
+| An Airbase endpoint without a typed method on `AirbaseDaikinClient`, and any method but GET | The reply fields. |
+| Airbase `/aircon/get_zone_setting` and `set_zone_setting` on a unit without zones | What such a unit answers. |
 
 These answers are a simulator's own choice, where an adapter's is not known:
 
@@ -88,3 +108,8 @@ These answers are a simulator's own choice, where an adapter's is not known:
 | Still answers `f_dir` in `/aircon/get_control_info` on a classic simulator started with a `unit` whose `swing` is `none` | Whether a classic unit without a louver reports the field. |
 | Makes a request wait while it answers another | Whether an adapter also drops a connection while it is busy. |
 | Answers a discovery probe from UDP port 30050 of its address | The port an adapter answers from. |
+| Answers HTTP 404 to every path outside `/skyfi`, on an Airbase simulator | Which paths besides `/common/basic_info` an Airbase adapter answers 404. |
+| Answers `ret=PARAM NG` to an Airbase `/aircon/set_control_info` without `pow`, `mode`, `stemp`, `shum`, `f_rate`, `f_auto`, `f_airside` or `f_dir`, and to a `set_zone_setting` without `zone_name` or `zone_onoff` | Which requests an Airbase adapter answers `PARAM NG`, and whether it takes a write without one of them. |
+| Keeps what an Airbase unit remembers for cool or for heat equal to what it holds, and names that mode in `bk_auto` once the unit is set to it | What an Airbase unit remembers on its own, and when it changes `bk_auto`. |
+| Reports no `shum`, no `adp_kind` and no `adv` on an Airbase simulator, and `model=NOTSUPPORT` | Which of them an Airbase adapter reports, and what its `model` holds on each unit. |
+| Holds the lists of an Airbase `get_zone_setting` with `%3B` for each `;`, and as many names as the unit has zones | The letter case an adapter sends, and whether it names more zones than `en_zone` counts. |

package/dist/clients/airbase.d.ts

@@ -0,0 +1,64 @@
+import type { DaikinCapabilities } from "../models/capabilities.js";
+import type { DaikinDeviceInfo } from "../models/device.js";
+import type { DaikinControl, DaikinSensors, DaikinState, DaikinStateAndSensors, SpecialMode } from "../models/state.js";
+import type { DaikinZone } from "../models/zone.js";
+import { type DaikinRequestOptions, type DaikinRetryOptions, type DaikinTransport } from "../transport.js";
+import type { DaikinClient } from "./client.js";
+/** Whether the adapter `transport` reaches is an Airbase adapter: one that
+ * answers HTTP 404 at `/common/basic_info`, where a classic adapter answers,
+ * and `ret=OK` at `/skyfi/common/basic_info`. It sends the second request
+ * only after that 404, and retries a refused or dropped connection as
+ * `withRetry` does by default: an adapter drops one while it answers another
+ * caller. It resolves with `false` when either request fails any other way.
+ * `discoverDevices` calls it, and `src/index.ts` does not export it. */
+export declare function isAirbaseAdapter(transport: DaikinTransport): Promise<boolean>;
+/** Airbase adapter (BRP15B61), on a ducted unit. Reads and writes are HTTP GET
+ * with query parameters, as on a classic adapter, at paths under `/skyfi`.
+ * It takes no terminal uuid and no local password. */
+export declare class AirbaseDaikinClient implements DaikinClient {
+    private readonly transport;
+    private readonly retryOptions?;
+    private capabilityFields;
+    private readonly setStateCache;
+    /** `close` closes `transport`, so give each client a transport of its own.
+     * `maxStateAgeForSetStateInMs` defaults to 0: see
+     * `CreateDaikinClientOptions.maxStateAgeForSetStateInMs`. */
+    constructor(transport: DaikinTransport, retryOptions?: DaikinRetryOptions | undefined, maxStateAgeForSetStateInMs?: number);
+    close(): Promise<void>;
+    getDeviceInfo(): Promise<DaikinDeviceInfo>;
+    getCapabilities(): Promise<DaikinCapabilities>;
+    getState(): Promise<DaikinState>;
+    setState(control: DaikinControl): Promise<void>;
+    getSensors(): Promise<DaikinSensors>;
+    getStateAndSensors(): Promise<DaikinStateAndSensors>;
+    /** Rejects with a `DaikinError` whose status is 501: an Airbase adapter has
+     * no known request for a special mode. */
+    setSpecialMode(_mode: SpecialMode, _enabled: boolean): Promise<void>;
+    /** Whether fan auto is on: the unit then picks the fan speed itself, up to
+     * the one that is set. `null` on a unit that takes no fan auto. */
+    getFanAuto(): Promise<boolean | null>;
+    /** Switches fan auto on or off. It switches airside off, and keeps the fan
+     * speed. Check `getFanAuto` first: the client sends it to any unit. */
+    setFanAuto(enabled: boolean): Promise<void>;
+    /** Whether airside is on. `null` on a unit that takes no airside. */
+    getAirside(): Promise<boolean | null>;
+    /** Switches airside on or off. Switching it on switches fan auto off and
+     * sets the lowest fan speed. Check `getAirside` first: the client sends it
+     * to any unit. */
+    setAirside(enabled: boolean): Promise<void>;
+    /** The unit's zones, in the unit's order; empty on a unit without zones,
+     * which is not asked for any. */
+    getZones(): Promise<DaikinZone[]>;
+    /** Opens or closes the zone at `index` in `getZones`, counted from 0. It
+     * rejects with an `Error` for an index the unit has no zone at. */
+    setZone(index: number, enabled: boolean): Promise<void>;
+    /** Calls any endpoint by its path below `/skyfi`, such as
+     * `/aircon/get_control_info`, with query parameters, and returns the reply's
+     * `key=value` fields. 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 readZoneSetting;
+    private readControlInfo;
+    private readCapabilityFields;
+}
+//# sourceMappingURL=airbase.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"airbase.d.ts","sourceRoot":"","sources":["../../src/clients/airbase.ts"],"names":[],"mappings":"AAwBA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AACpE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,KAAK,EACV,aAAa,EACb,aAAa,EACb,WAAW,EACX,qBAAqB,EACrB,WAAW,EACZ,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EACL,KAAK,oBAAoB,EACzB,KAAK,kBAAkB,EACvB,KAAK,eAAe,EAErB,MAAM,iBAAiB,CAAC;AACzB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAmBhD;;;;;;wEAMwE;AACxE,wBAAsB,gBAAgB,CACpC,SAAS,EAAE,eAAe,GACzB,OAAO,CAAC,OAAO,CAAC,CAoBlB;AAED;;sDAEsD;AACtD,qBAAa,mBAAoB,YAAW,YAAY;IASpD,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAC;IARhC,OAAO,CAAC,gBAAgB,CAA8C;IACtE,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAgB;IAE9C;;iEAE6D;IAC7D,YACmB,SAAS,EAAE,eAAe,EAC1B,YAAY,CAAC,EAAE,kBAAkB,YAAA,EAClD,0BAA0B,SAAI,EAG/B;IAED,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAErB;IAEK,aAAa,IAAI,OAAO,CAAC,gBAAgB,CAAC,CAE/C;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,CAQpD;IAEK,UAAU,IAAI,OAAO,CAAC,aAAa,CAAC,CAIzC;IAEK,kBAAkB,IAAI,OAAO,CAAC,qBAAqB,CAAC,CAEzD;IAED;8CAC0C;IACpC,cAAc,CAAC,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAEzE;IAID;uEACmE;IAC7D,UAAU,IAAI,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC,CAI1C;IAED;2EACuE;IACjE,UAAU,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAQhD;IAED,qEAAqE;IAC/D,UAAU,IAAI,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC,CAI1C;IAED;;sBAEkB;IACZ,UAAU,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAQhD;IAED;qCACiC;IAC3B,QAAQ,IAAI,OAAO,CAAC,UAAU,EAAE,CAAC,CAMtC;IAED;uEACmE;IAC7D,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAO5D;IAED;;;mBAGe;IACT,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,CAqBjC;YAIa,eAAe;YAQf,eAAe;IAM7B,OAAO,CAAC,oBAAoB;CAY7B"}