@kusinta/iot-schema 0.2.0-beta.45 → 0.2.0-beta.47

package/src/kusinta/iot/climate/v1/climate_pb.d.ts

@@ -6,6 +6,7 @@ import type { GenEnum, GenFile, GenMessage } from "@bufbuild/protobuf/codegenv2"
 import type { Message } from "@bufbuild/protobuf";
 import type { Timestamp } from "@bufbuild/protobuf/wkt";
 import type { DeviceId, SpaceId, UserId } from "../../identity/v1/identity_pb.js";
+import type { Role } from "../../access/v1/roles_pb.js";
 
 /**
  * Describes the file kusinta/iot/climate/v1/climate.proto.
@@ -49,6 +50,15 @@ export declare type TargetChange = Message<"kusinta.iot.climate.v1.TargetChange"
      */
     value: DeviceId;
     case: "device";
+  } | {
+    /**
+     * Set by the gateway when the home gained a resident, from the room's outer move-in target
+     * (OuterRoomLimits.move_in_target; webrtc.v1 household.proto, MOVE-IN). Only true is sent.
+     *
+     * @generated from field: bool move_in = 4;
+     */
+    value: boolean;
+    case: "moveIn";
   } | { case: undefined; value?: undefined };
 };
 
@@ -76,7 +86,16 @@ export declare type RoomClimate = Message<"kusinta.iot.climate.v1.RoomClimate">
 
   /**
    * The temperature the room is to be held at, in centidegrees. Unset: nobody has set
-   * one. Always within [min_centidegrees, max_centidegrees] where those are set.
+   * one. Always within the inner limits where those are set (inner_limits), and bounded by
+   * nothing of the room where they are not. Never clamped by the outer ones, a change made by
+   * hand at a device they bind included: the target keeps the change, and that device's output
+   * is held within them (OuterRoomLimits, WHAT THEY BIND and DEVICE LIMITS).
+   *
+   * Rollout note: an app that predates outer_limits reads min_centidegrees and
+   * max_centidegrees as bounds on this field, and may be sent a target outside them; one that
+   * holds its control to them may, on any touch, send the outer bound as the target and so
+   * rewrite a household's target set beyond it. An app tells a gateway that predates outer
+   * limits by outer_limits unset, and offers it only min and max (ConfigureRoomClimate.limits).
    *
    * @generated from field: optional sint32 target_centidegrees = 2;
    */
@@ -84,7 +103,8 @@ export declare type RoomClimate = Message<"kusinta.iot.climate.v1.RoomClimate">
 
   /**
    * Who or what set target_centidegrees. Unset while the target is, and when it is withheld
-   * from the recipient: from service in a home, and from anyone when it dates from before
+   * from the recipient: from service in a home that is not empty (webrtc.v1 household.proto,
+   * EMPTY HOME), and from anyone when it dates from before
    * their current residency in the home, or from a home they did not live in at the time
    * (see access.v1.MembershipRelation).
    *
@@ -96,7 +116,10 @@ export declare type RoomClimate = Message<"kusinta.iot.climate.v1.RoomClimate">
    * What the valves are actually being held at, in centidegrees. Equal to the target
    * unless a ClimateMode on an enclosing space sets the room back — and then the room's
    * own target again if somebody changed this room during the mode (see
-   * overrides_mode). Unset while nothing is being held.
+   * overrides_mode) — or the vacancy setback holds it (webrtc.v1 household.proto, VACANCY), or
+   * an outer bound clamps it (outer_limit_clamp). Where the outer limits bind some of the
+   * room's outputs and not others, what those they bind are held at (OuterRoomLimits, HELD).
+   * Unset while nothing is being held.
    *
    * @generated from field: optional sint32 effective_target_centidegrees = 4;
    */
@@ -119,17 +142,19 @@ export declare type RoomClimate = Message<"kusinta.iot.climate.v1.RoomClimate">
   modeSpaceId?: SpaceId | undefined;
 
   /**
-   * The owner's limits, in centidegrees. The gateway writes them to every device in the
-   * room (Matter Min/MaxHeatSetpointLimit), so a knob stops at them physically, and
-   * clamps every target — from the app, a knob or a mode — to them. The minimum is also
-   * the floor under a mode's setback.
+   * A copy of outer_limits.min and .max, in centidegrees, kept for apps that predate
+   * outer_limits: each set exactly when its outer bound is, and unset otherwise. Read
+   * outer_limits instead. What the gateway writes into a device's own setpoint limits is
+   * OuterRoomLimits' (DEVICE LIMITS).
    *
-   * @generated from field: optional sint32 min_centidegrees = 6;
+   * @generated from field: optional sint32 min_centidegrees = 6 [deprecated = true];
+   * @deprecated
    */
   minCentidegrees?: number | undefined;
 
   /**
-   * @generated from field: optional sint32 max_centidegrees = 7;
+   * @generated from field: optional sint32 max_centidegrees = 7 [deprecated = true];
+   * @deprecated
    */
   maxCentidegrees?: number | undefined;
 
@@ -186,8 +211,9 @@ export declare type RoomClimate = Message<"kusinta.iot.climate.v1.RoomClimate">
    * Stated as the lock rather than as a permission so that the proto3 default — false,
    * unlocked — is the intended default: a room nobody has configured takes changes at its
    * devices, as a room in an apartment should until its residents decide otherwise; when a
-   * home loses its last resident, its rooms' locks are cleared. Elsewhere locking is the
-   * owner's choice.
+   * home loses its last resident, its rooms' locks are cleared, and so are those set while it
+   * stood empty when it gains one (webrtc.v1 household.proto, MOVE-IN). Elsewhere locking is
+   * the owner's choice.
    *
    * @generated from field: bool lock_device_controls = 12;
    */
@@ -195,16 +221,19 @@ export declare type RoomClimate = Message<"kusinta.iot.climate.v1.RoomClimate">
 
   /**
    * Set when the recipient reaches this room only as service (see
-   * access.v1.MembershipRelation): the room is in someone's home, and what describes the
-   * people in it is WITHHELD — target_centidegrees, target_change,
-   * effective_target_centidegrees, overrides_mode, mode_space_id, measured_centidegrees,
-   * measured_by, condition and lock_device_controls are all left unset, and sensor_ids
-   * leaves out sensors a resident owns.
+   * access.v1.MembershipRelation): the room is in someone's home, and what describes the people
+   * in it is WITHHELD. Never set for the property owner or a gateway administrator while the
+   * home is empty (webrtc.v1 household.proto, EMPTY HOME): they are sent its rooms as rooms
+   * outside homes are, and at MOVE-IN sent them again with it set. When it is set,
+   * target_centidegrees, target_change, effective_target_centidegrees, overrides_mode,
+   * mode_space_id, measured_centidegrees, measured_by, condition, lock_device_controls,
+   * inner_limits, outer_limit_clamp, outer_limits_coverage and outer_bound_device_ids are all
+   * left unset, and sensor_ids leaves out sensors a resident owns.
    *
    * Unset because withheld, not because unknown: an app must not render them as NO_TARGET or
    * a lost sensor. A withheld room is sent again only when something that IS sent changes,
-   * so that the timing of an update does not give away what was withheld. Its limits and
-   * the sensors service may see are still sent, since setting a room up is service work.
+   * so that the timing of an update does not give away what was withheld. Its outer limits
+   * and the sensors service may see are still sent, since setting a room up is service work.
    * Its climate over time is available to service only as an ApartmentClimateSummary.
    *
    * explanations, target_held_until, planning and the comfort band are withheld in the
@@ -253,8 +282,9 @@ export declare type RoomClimate = Message<"kusinta.iot.climate.v1.RoomClimate">
   /**
    * The comfort band in force, in centidegrees: the lowest and highest a plan may hold the
    * room at while it heats ahead, coasts or saves on dear energy. Both set or neither, low
-   * no higher than high, and within [min_centidegrees, max_centidegrees] where those are
-   * set. Absent: no band, and a plan holds the room at its target — never 0 °C.
+   * no higher than high, and within the inner limits where those are set; at the outputs the
+   * outer limits bind, a plan holds within them too (OuterRoomLimits, HELD). Absent: no band,
+   * and a plan holds the room at its target — never 0 °C.
    *
    * @generated from field: optional sint32 comfort_band_low_centidegrees = 19;
    */
@@ -264,6 +294,61 @@ export declare type RoomClimate = Message<"kusinta.iot.climate.v1.RoomClimate">
    * @generated from field: optional sint32 comfort_band_high_centidegrees = 20;
    */
   comfortBandHighCentidegrees?: number | undefined;
+
+  /**
+   * The room's outer limits, each bound with who set it and when (OuterRoomLimits). Sent to
+   * whoever is sent the room, service included and with state_withheld too: they are the
+   * building's, and setting them is service work.
+   *
+   * Always set by a gateway that keeps outer limits: an empty OuterRoomLimits where the room
+   * has none. Unset only from a gateway that predates them, which keeps min and max alone: an
+   * app reads unset so, and offers only min and max, through ConfigureRoomClimate.limits,
+   * rather than an editor whose away minimum and move-in target that gateway would drop.
+   *
+   * @generated from field: kusinta.iot.climate.v1.OuterRoomLimits outer_limits = 21;
+   */
+  outerLimits?: OuterRoomLimits | undefined;
+
+  /**
+   * The household's limits (InnerRoomLimits). Sent to the home's residents only, and never with
+   * state_withheld. Unset: none, or a room outside homes.
+   *
+   * @generated from field: kusinta.iot.climate.v1.InnerRoomLimits inner_limits = 22;
+   */
+  innerLimits?: InnerRoomLimits | undefined;
+
+  /**
+   * Set while an outer bound holds the outputs it binds away from where the room would be held
+   * without it — the household's target, its inner limits or its mode's setback — so the
+   * household is told which bound does it, and from outer_limits the role behind it and since
+   * when. Gone once nothing is clamped. Sent as outer_limits_coverage is.
+   *
+   * @generated from field: kusinta.iot.climate.v1.OuterLimitClamp outer_limit_clamp = 23;
+   */
+  outerLimitClamp?: OuterLimitClamp | undefined;
+
+  /**
+   * How many of the room's heating outputs the outer limits bind, so that an app shows the
+   * building's bounds where they apply and not where they do not. In a home, sent to its
+   * residents only: to anyone else it would tell whether the room holds a device a resident
+   * owns. Outside homes, sent to whoever is sent the room, judged over the outputs of devices
+   * the recipient sees, so that a device hidden from them changes nothing they are sent.
+   *
+   * @generated from field: kusinta.iot.climate.v1.OuterLimitsCoverage outer_limits_coverage = 24;
+   */
+  outerLimitsCoverage: OuterLimitsCoverage;
+
+  /**
+   * The devices in the room with a heating output the outer limits bind
+   * (OuterRoomLimits, WHAT THEY BIND), so that an app marks a device's own limit settings as
+   * governed by them only where they are. Sent as outer_limits_coverage is, and judged over the
+   * same devices: outside homes, only devices the recipient sees are listed. Empty under
+   * coverage NONE or UNSPECIFIED; under ALL, every heating device in the room the recipient
+   * sees is in it; under SOME, some are.
+   *
+   * @generated from field: repeated kusinta.iot.identity.v1.DeviceId outer_bound_device_ids = 25;
+   */
+  outerBoundDeviceIds: DeviceId[];
 };
 
 /**
@@ -272,6 +357,198 @@ export declare type RoomClimate = Message<"kusinta.iot.climate.v1.RoomClimate">
  */
 export declare const RoomClimateSchema: GenMessage<RoomClimate>;
 
+/**
+ * One bound of a room's outer limits, with who set it and when. Shown to the household as the
+ * role and the time, never a name: "building administrator, since …".
+ *
+ * @generated from message kusinta.iot.climate.v1.OuterLimit
+ */
+export declare type OuterLimit = Message<"kusinta.iot.climate.v1.OuterLimit"> & {
+  /**
+   * @generated from field: sint32 centidegrees = 1;
+   */
+  centidegrees: number;
+
+  /**
+   * The role its setter acted in (webrtc.v1.ConfigureRoomClimate): ROLE_PROPERTY_OWNER where
+   * they hold it, else ROLE_GATEWAY_ADMIN, else ROLE_TECHNICIAN. In a home, a bound an
+   * installer set under a commissioning grant has it unset to anyone but the home's residents:
+   * staff are shown its value and set_at alone, so the stamp tells them nothing of when the
+   * household let an installer in. An app shows an unset role as not stated.
+   *
+   * @generated from field: kusinta.iot.access.v1.Role set_by_role = 2;
+   */
+  setByRole: Role;
+
+  /**
+   * When the bound was last given a new value. Always sent, also when it dates from before the
+   * recipient's residency: it records an act of the building's, and nothing of a household.
+   *
+   * @generated from field: google.protobuf.Timestamp set_at = 3;
+   */
+  setAt?: Timestamp | undefined;
+};
+
+/**
+ * Describes the message kusinta.iot.climate.v1.OuterLimit.
+ * Use `create(OuterLimitSchema)` to create a new message.
+ */
+export declare const OuterLimitSchema: GenMessage<OuterLimit>;
+
+/**
+ * A room's outer limits: the building's bounds on the heating it owns, set by the parties
+ * webrtc.v1.ConfigureRoomClimate names. Every bound is optional: a building where each home
+ * pays its own heating may set floors only.
+ *
+ * WHAT THEY BIND. The asset owner decides whether they can bind a device, and the
+ * organisation whether to use them. They bind an output only on one of the building's own
+ * devices (common.v1.DeviceOwnershipType COMPANY) whose asset owner is the organisation, or
+ * that has none recorded (common.v1.AssetOwner); never a household's asset, nor a device a
+ * person owns outright. The clamp is applied per output, by its device's owner: in a room with
+ * a valve the organisation owns and a heater a resident owns, the valve is held within the
+ * outer limits and the heater at the room's target. So they bind outputs, never the room: the
+ * room's target and its inner limits are the household's, are not rewritten when an outer bound
+ * moves, and hold again at those outputs once it moves back out.
+ *
+ * HELD. What an output is held at is worked out in this order, each step clamping the one
+ * before:
+ *   1. the room's target, or while a mode (ClimateMode) sets the room back its setback;
+ *   2. the inner limits (InnerRoomLimits): the maximum always, the minimum — the household's
+ *      everyday floor — only while no mode sets the room back;
+ *   3. at an output the outer limits bind: [min, max] while no mode sets the room back, and
+ *      [AWAY FLOOR, max] while one does; during the vacancy setback (webrtc.v1 household.proto,
+ *      VACANCY), the AWAY FLOOR itself;
+ *   4. an installer's equipment-safety limits — a floor's surface maximum, a supply cap
+ *      (commissioning.v1) — which neither tier of comfort limits widens.
+ * So where an inner bound and an outer bound disagree the outer one wins, and the household's
+ * range at those outputs is always inside the building's; outputs the outer limits do not bind
+ * stop at step 2. The AWAY FLOOR is away_min, or min where away_min is unset: kept apart from
+ * min so that a household going away may set back below its everyday floor but never below what
+ * the building needs — frost, damp, heat drawn from neighbours. With neither set, a room has no
+ * away floor, and no vacancy setback.
+ *
+ * DEVICE LIMITS. Where the gateway writes a room's outer limits into a device's own setpoint
+ * limits (Matter Min/MaxHeatSetpointLimit), so that a knob stops at them, it writes them only
+ * to devices they bind (WHAT THEY BIND), and writes the AWAY FLOOR as the minimum and max as
+ * the maximum, each only where set: a device holding min as its own minimum would refuse the
+ * setbacks of step 3. Outside a setback the gateway holds min itself: a change made by hand at
+ * such a device below min is adopted as the room's target as it was made, within the inner
+ * limits and never clamped by the outer ones, while the device's output is held at min and min
+ * is written back to it. Into a device the outer limits do not bind that holds room limits
+ * written before, it writes the device's defaults back, queued and retried as the wipe's device
+ * writes are (webrtc.v1 household.proto, WIPE).
+ *
+ * They stay with the home: a household handover wipes the inner limits, never these
+ * (webrtc.v1 household.proto, WIPE).
+ *
+ * @generated from message kusinta.iot.climate.v1.OuterRoomLimits
+ */
+export declare type OuterRoomLimits = Message<"kusinta.iot.climate.v1.OuterRoomLimits"> & {
+  /**
+   * The normal minimum and maximum.
+   *
+   * @generated from field: kusinta.iot.climate.v1.OuterLimit min = 1;
+   */
+  min?: OuterLimit | undefined;
+
+  /**
+   * @generated from field: kusinta.iot.climate.v1.OuterLimit max = 2;
+   */
+  max?: OuterLimit | undefined;
+
+  /**
+   * The floor under a setback; see AWAY FLOOR above.
+   *
+   * @generated from field: kusinta.iot.climate.v1.OuterLimit away_min = 3;
+   */
+  awayMin?: OuterLimit | undefined;
+
+  /**
+   * The target the room starts at when an empty home gains a resident (webrtc.v1
+   * household.proto, MOVE-IN). A start, never a limit, and a target like any other. Always
+   * within [min, max] where those are set (webrtc.v1.ConfigureRoomClimate, "limits_order").
+   *
+   * @generated from field: kusinta.iot.climate.v1.OuterLimit move_in_target = 4;
+   */
+  moveInTarget?: OuterLimit | undefined;
+
+  /**
+   * Set while min was set below the gateway's public-health threshold: the threshold in force
+   * then, which min's setter explicitly accepted going below (ConfigureRoomClimate
+   * .accept_below_threshold). The acceptance is recorded with min's set_by_role and set_at.
+   * Unset while min is unset or was set at or above the threshold. A threshold changed later
+   * re-judges nothing already set.
+   *
+   * @generated from field: optional sint32 min_accepted_threshold_centidegrees = 5;
+   */
+  minAcceptedThresholdCentidegrees?: number | undefined;
+};
+
+/**
+ * Describes the message kusinta.iot.climate.v1.OuterRoomLimits.
+ * Use `create(OuterRoomLimitsSchema)` to create a new message.
+ */
+export declare const OuterRoomLimitsSchema: GenMessage<OuterRoomLimits>;
+
+/**
+ * A room's inner limits: the household's own minimum and maximum, set by the home's household
+ * admins (webrtc.v1.SetInnerRoomLimits). They clamp the room's target, from the app or a knob
+ * alike, and setting them clamps the target already set. They apply to every output in the
+ * room, a household's own devices included, as OuterRoomLimits (HELD) orders them. Household
+ * data: never told to anyone but the home's residents, and wiped at a handover (webrtc.v1
+ * household.proto, WIPE). They belong to the room while it is in the home: cleared when it
+ * leaves the home, or the space stops being an apartment, so an empty home's rooms hold none
+ * and a move-in target meets none.
+ *
+ * @generated from message kusinta.iot.climate.v1.InnerRoomLimits
+ */
+export declare type InnerRoomLimits = Message<"kusinta.iot.climate.v1.InnerRoomLimits"> & {
+  /**
+   * @generated from field: optional sint32 min_centidegrees = 1;
+   */
+  minCentidegrees?: number | undefined;
+
+  /**
+   * @generated from field: optional sint32 max_centidegrees = 2;
+   */
+  maxCentidegrees?: number | undefined;
+};
+
+/**
+ * Describes the message kusinta.iot.climate.v1.InnerRoomLimits.
+ * Use `create(InnerRoomLimitsSchema)` to create a new message.
+ */
+export declare const InnerRoomLimitsSchema: GenMessage<InnerRoomLimits>;
+
+/**
+ * An outer bound clamping a room (RoomClimate.outer_limit_clamp).
+ *
+ * @generated from message kusinta.iot.climate.v1.OuterLimitClamp
+ */
+export declare type OuterLimitClamp = Message<"kusinta.iot.climate.v1.OuterLimitClamp"> & {
+  /**
+   * Which bound. An app that does not know the value shows that the building's limits clamp the
+   * room, without naming one.
+   *
+   * @generated from field: kusinta.iot.climate.v1.OuterLimitKind limit = 1;
+   */
+  limit: OuterLimitKind;
+
+  /**
+   * Where the room would be held without it, in centidegrees: where outputs the outer limits do
+   * not bind are held. effective_target_centidegrees is where those they bind are.
+   *
+   * @generated from field: optional sint32 unclamped_centidegrees = 2;
+   */
+  unclampedCentidegrees?: number | undefined;
+};
+
+/**
+ * Describes the message kusinta.iot.climate.v1.OuterLimitClamp.
+ * Use `create(OuterLimitClampSchema)` to create a new message.
+ */
+export declare const OuterLimitClampSchema: GenMessage<OuterLimitClamp>;
+
 /**
  * One reason a room, or a part of its heating, is where it is.
  *
@@ -345,8 +622,8 @@ export declare type ClimateMode = Message<"kusinta.iot.climate.v1.ClimateMode">
 
   /**
    * The temperature every room is set back to, in centidegrees. Required while a mode is
-   * on — a mode with nothing to set back to is refused, not defaulted. Clamped by each
-   * room's min_centidegrees, which is the frost floor.
+   * on — a mode with nothing to set back to is refused, not defaulted. Clamped in each room as
+   * OuterRoomLimits (HELD) orders, the away floor being what the building needs.
    *
    * @generated from field: optional sint32 setback_centidegrees = 3;
    */
@@ -357,7 +634,8 @@ export declare type ClimateMode = Message<"kusinta.iot.climate.v1.ClimateMode">
    * targets — warm by then, not starting to heat (see warm_from). AWAY: starts_at is when it
    * was switched on; ends_at is unset. starts_at is unset when it dates from before the
    * recipient's current residency in the home, or from a home they did not live in at the
-   * time; an ends_at ahead is always sent.
+   * time, save to the property owner and the gateway administrators for a mode on a home while
+   * it is empty (webrtc.v1 household.proto, EMPTY HOME); an ends_at ahead is always sent.
    *
    * @generated from field: google.protobuf.Timestamp starts_at = 4;
    */
@@ -371,7 +649,9 @@ export declare type ClimateMode = Message<"kusinta.iot.climate.v1.ClimateMode">
   /**
    * Who switched it on. Unset when it is withheld from the recipient: from service in a
    * home, and from anyone when it dates from before their current residency in the home, or
-   * from a home they did not live in at the time (see access.v1.MembershipRelation).
+   * from a home they did not live in at the time (see access.v1.MembershipRelation). The
+   * property owner and the gateway administrators are given it for a mode on a home while it is
+   * empty, which only they can have switched on (webrtc.v1 household.proto, EMPTY HOME).
    *
    * @generated from field: kusinta.iot.identity.v1.UserId set_by = 6;
    */
@@ -417,22 +697,26 @@ export declare type RoomClimateList = Message<"kusinta.iot.climate.v1.RoomClimat
 export declare const RoomClimateListSchema: GenMessage<RoomClimateList>;
 
 /**
- * One fixed 15-minute bucket of a room's history. Every reading is optional: absent
- * means nothing was known for that bucket, never zero.
+ * One bucket of a room's history, of the length RoomHistory.resolution names. Every reading
+ * is optional: absent means nothing was known for that bucket, never zero.
+ *
+ * An hour is made of its quarter hours, each reading as stated beside it. A reading none of
+ * the hour's quarter hours knew is absent in the hour too; a mean is taken over the quarter
+ * hours that knew one, and a sum likewise, so an hour partly unknown sums only what was known.
  *
  * @generated from message kusinta.iot.climate.v1.RoomHistorySample
  */
 export declare type RoomHistorySample = Message<"kusinta.iot.climate.v1.RoomHistorySample"> & {
   /**
-   * The start of the bucket. Buckets are fixed 15-minute intervals aligned to UTC
-   * quarter hours (:00, :15, :30, :45).
+   * The start of the bucket.
    *
    * @generated from field: google.protobuf.Timestamp at = 1;
    */
   at?: Timestamp | undefined;
 
   /**
-   * The mean of the room's measured temperature over the bucket, in centidegrees.
+   * The mean of the room's measured temperature over the bucket, in centidegrees. An hour:
+   * the mean of its quarter hours' means.
    *
    * @generated from field: optional sint32 measured_centidegrees = 2;
    */
@@ -440,7 +724,8 @@ export declare type RoomHistorySample = Message<"kusinta.iot.climate.v1.RoomHist
 
   /**
    * RoomClimate.target_centidegrees and .effective_target_centidegrees as they were in
-   * force at the bucket's start, in centidegrees.
+   * force at the bucket's start, in centidegrees. An hour: its first quarter hour's, and so
+   * absent when that quarter hour did not know them, whatever the later ones knew.
    *
    * @generated from field: optional sint32 target_centidegrees = 3;
    */
@@ -453,14 +738,16 @@ export declare type RoomHistorySample = Message<"kusinta.iot.climate.v1.RoomHist
 
   /**
    * The mean opening over the bucket across the room's valves that report one, in
-   * thousandths of fully open. Absent if none of them does.
+   * thousandths of fully open. Absent if none of them does. An hour: the mean of its quarter
+   * hours' means.
    *
    * @generated from field: optional uint32 valve_open_permille = 5;
    */
   valveOpenPermille?: number | undefined;
 
   /**
-   * The seconds within the bucket during which any of the room's valves was open.
+   * The seconds within the bucket during which any of the room's valves was open. An hour:
+   * the sum of its quarter hours', so up to 3600.
    *
    * @generated from field: optional uint32 valve_open_seconds = 6;
    */
@@ -471,7 +758,8 @@ export declare type RoomHistorySample = Message<"kusinta.iot.climate.v1.RoomHist
    * (heating.v1.FloorZone), counted from the contact state the zone's output reports, read
    * through its closed_value, not from what was commanded. Kept apart from the valve
    * fields: a zone's duty and a valve's opening are different controls with different time
-   * scales. Absent where no floor zone heats the room.
+   * scales. Absent where no floor zone heats the room. An hour: the sum of its quarter
+   * hours', as valve_open_seconds.
    *
    * @generated from field: optional uint32 floor_heating_seconds = 7;
    */
@@ -485,7 +773,13 @@ export declare type RoomHistorySample = Message<"kusinta.iot.climate.v1.RoomHist
 export declare const RoomHistorySampleSchema: GenMessage<RoomHistorySample>;
 
 /**
- * A room's history, in reply to GetRoomHistory.
+ * A room's history at one resolution, in reply to GetRoomHistory.
+ *
+ * A bucket is given only once the gateway has made it, never before it ends, and only where
+ * all of it lies within what the recipient may read. The covered range is over bucket starts,
+ * as the request's range is: a bucket is within it when covered_from <= at < covered_to. A
+ * bucket within it that is not among the samples is one for which nothing is known; of any
+ * other bucket this answer says nothing, and an app MUST NOT show it as empty on its account.
  *
  * @generated from message kusinta.iot.climate.v1.RoomHistory
  */
@@ -496,22 +790,60 @@ export declare type RoomHistory = Message<"kusinta.iot.climate.v1.RoomHistory">
   roomId?: SpaceId | undefined;
 
   /**
-   * The earliest moment the gateway still holds for this room. The request's from_time
-   * and to_time are clamped to [kept_from, now], so nothing before kept_from is ever
-   * returned. For a room in the recipient's own home it is no earlier than the start of
-   * their current residency, nor than when the room last joined their home; for any other
-   * room, no earlier than when it last left a home.
+   * The start of the earliest bucket the gateway still holds for this room at this resolution
+   * that the recipient may read. The request's from_time and to_time are clamped to
+   * [kept_from, now], so nothing before kept_from is ever returned. For a room in the
+   * recipient's own home it is no earlier than the start of their current residency, nor than
+   * when the room last joined their home; for any other room, no earlier than when it last
+   * left a home. How far back the room's history reaches for the recipient, whether or not
+   * this answer reaches that far. Always set: where nothing is held for the recipient at this
+   * resolution, it is no earlier than covered_to.
    *
    * @generated from field: google.protobuf.Timestamp kept_from = 2;
    */
   keptFrom?: Timestamp | undefined;
 
   /**
-   * The buckets within the clamped range, in order of `at`.
+   * The buckets within [covered_from, covered_to), in order of `at`.
    *
    * @generated from field: repeated kusinta.iot.climate.v1.RoomHistorySample samples = 3;
    */
   samples: RoomHistorySample[];
+
+  /**
+   * The length of the samples' buckets. An app labels and plots them by this, never by the
+   * resolution it asked for.
+   *
+   * @generated from field: kusinta.iot.climate.v1.RoomHistoryResolution resolution = 4;
+   */
+  resolution: RoomHistoryResolution;
+
+  /**
+   * The range this answer covers, [covered_from, covered_to). Both unset only in an answer
+   * from a gateway that predates them, which caps nothing: it covers the range asked, clamped.
+   *
+   * covered_to is the request's to_time as clamped, but never later than the start of the
+   * oldest bucket at this resolution the gateway has still to make — for an hour, possibly
+   * days after it ends — so no bucket within the range is made later. The time after it may be
+   * held at a finer resolution, and an app asks for it there.
+   *
+   * covered_from is the request's from_time as clamped, unless more than 768 samples fall
+   * between it and covered_to: then the answer is capped, keeping the newest 768, and
+   * covered_from is samples[0].at. Either way it is never later than covered_to, and an answer
+   * that covers nothing has the two equal.
+   *
+   * An answer is capped exactly when covered_from is later than kept_from and than the
+   * from_time asked for, if one was. The app asks for the next page with the same from_time,
+   * this answer's resolution, and to_time = covered_from, until an answer is not capped.
+   *
+   * @generated from field: google.protobuf.Timestamp covered_from = 5;
+   */
+  coveredFrom?: Timestamp | undefined;
+
+  /**
+   * @generated from field: google.protobuf.Timestamp covered_to = 6;
+   */
+  coveredTo?: Timestamp | undefined;
 };
 
 /**
@@ -723,6 +1055,81 @@ export enum RoomClimateCondition {
  */
 export declare const RoomClimateConditionSchema: GenEnum<RoomClimateCondition>;
 
+/**
+ * Which bound of a room's outer limits clamps the outputs it binds.
+ *
+ * @generated from enum kusinta.iot.climate.v1.OuterLimitKind
+ */
+export enum OuterLimitKind {
+  /**
+   * @generated from enum value: OUTER_LIMIT_KIND_UNSPECIFIED = 0;
+   */
+  UNSPECIFIED = 0,
+
+  /**
+   * Also when min stands in as the AWAY FLOOR for an unset away_min.
+   *
+   * @generated from enum value: OUTER_LIMIT_KIND_MIN = 1;
+   */
+  MIN = 1,
+
+  /**
+   * @generated from enum value: OUTER_LIMIT_KIND_MAX = 2;
+   */
+  MAX = 2,
+
+  /**
+   * @generated from enum value: OUTER_LIMIT_KIND_AWAY_MIN = 3;
+   */
+  AWAY_MIN = 3,
+}
+
+/**
+ * Describes the enum kusinta.iot.climate.v1.OuterLimitKind.
+ */
+export declare const OuterLimitKindSchema: GenEnum<OuterLimitKind>;
+
+/**
+ * How many of a room's heating outputs its outer limits bind (OuterRoomLimits, WHAT THEY BIND).
+ *
+ * @generated from enum kusinta.iot.climate.v1.OuterLimitsCoverage
+ */
+export enum OuterLimitsCoverage {
+  /**
+   * Not stated: withheld, or the room has no outer limits.
+   *
+   * @generated from enum value: OUTER_LIMITS_COVERAGE_UNSPECIFIED = 0;
+   */
+  UNSPECIFIED = 0,
+
+  /**
+   * The room has outer limits and they bind none of its heating outputs: it heats only with a
+   * household's own devices, or with nothing.
+   *
+   * @generated from enum value: OUTER_LIMITS_COVERAGE_NONE = 1;
+   */
+  NONE = 1,
+
+  /**
+   * Some of its heating outputs and not others.
+   *
+   * @generated from enum value: OUTER_LIMITS_COVERAGE_SOME = 2;
+   */
+  SOME = 2,
+
+  /**
+   * Every heating output in it.
+   *
+   * @generated from enum value: OUTER_LIMITS_COVERAGE_ALL = 3;
+   */
+  ALL = 3,
+}
+
+/**
+ * Describes the enum kusinta.iot.climate.v1.OuterLimitsCoverage.
+ */
+export declare const OuterLimitsCoverageSchema: GenEnum<OuterLimitsCoverage>;
+
 /**
  * Whether a plan steers a room: one that looks ahead at prices, weather and the heat
  * source and moves the room within its comfort band. A standing state of the room, not a
@@ -968,6 +1375,49 @@ export enum ClimateModeKind {
  */
 export declare const ClimateModeKindSchema: GenEnum<ClimateModeKind>;
 
+/**
+ * The length of the buckets a room's history is given in. Buckets are fixed and aligned to
+ * UTC, whatever the building's time zone.
+ *
+ * @generated from enum kusinta.iot.climate.v1.RoomHistoryResolution
+ */
+export enum RoomHistoryResolution {
+  /**
+   * In a request: the gateway chooses (webrtc.v1.GetRoomHistory). In an answer: quarter hours,
+   * from a gateway that predates this field.
+   *
+   * Rollout note: an app that predates this field asks with it unset and reads every sample as
+   * a quarter hour and every answer as whole. A gateway may therefore give hours, or cap an
+   * answer, only to apps that read RoomHistory.resolution and its covered range: app handling
+   * ships before or with the gateway that does.
+   *
+   * @generated from enum value: ROOM_HISTORY_RESOLUTION_UNSPECIFIED = 0;
+   */
+  UNSPECIFIED = 0,
+
+  /**
+   * 15-minute buckets (:00, :15, :30, :45).
+   *
+   * @generated from enum value: ROOM_HISTORY_RESOLUTION_QUARTER_HOUR = 1;
+   */
+  QUARTER_HOUR = 1,
+
+  /**
+   * Hour buckets, each made of its four quarter hours as RoomHistorySample says. An hour is
+   * given only where all of it lies within what the recipient may read (RoomHistory): one
+   * that straddles the start of their residency, or the room joining their home, is left out,
+   * never trimmed or averaged again from its readable part.
+   *
+   * @generated from enum value: ROOM_HISTORY_RESOLUTION_HOUR = 2;
+   */
+  HOUR = 2,
+}
+
+/**
+ * Describes the enum kusinta.iot.climate.v1.RoomHistoryResolution.
+ */
+export declare const RoomHistoryResolutionSchema: GenEnum<RoomHistoryResolution>;
+
 /**
  * The length of the periods an ApartmentClimateSummary is given in. Each period runs from
  * the start of one local date to the start of another in the building's time zone