@kusinta/iot-schema 0.2.0-beta.3 → 0.2.0-beta.30

package/src/kusinta/iot/webrtc/v1/management_pb.d.ts

@@ -5,8 +5,16 @@
 import type { GenFile, GenMessage } from "@bufbuild/protobuf/codegenv2";
 import type { Message } from "@bufbuild/protobuf";
 import type { DeviceOwnershipType, SpaceType } from "../../common/v1/types_pb.js";
-import type { DeviceId, SpaceId, UserId } from "../../identity/v1/identity_pb.js";
+import type { ConnectorId, DeviceId, SpaceId, UserId } from "../../identity/v1/identity_pb.js";
+import type { MembershipRelation, Role } from "../../access/v1/roles_pb.js";
+import type { LorawanProvisioning } from "../../vendor/lorawan/v1/lorawan_pb.js";
 import type { Space } from "../../space/v1/space_pb.js";
+import type { LinkFunction, LinkMode, LinkSettings } from "../../link/v1/link_pb.js";
+import type { ClimateModeKind, ClimateSummaryPeriod } from "../../climate/v1/climate_pb.js";
+import type { Timestamp } from "@bufbuild/protobuf/wkt";
+import type { ServiceSignal } from "../../access/v1/acl_pb.js";
+import type { ApproveJoinRequest, CreateInvite, DenyJoinRequest, ListSpaceInvites, MarkInviteEmailSent, ResendInvite, RevokeInvite } from "./invite_pb.js";
+import type { ListGatewayMembers, RemoveFromGateway, SetAccessUntil, SetMemberRole, SetOwnerOrganisation } from "./members_pb.js";
 
 /**
  * Describes the file kusinta/iot/webrtc/v1/management.proto.
@@ -18,6 +26,10 @@ export declare const file_kusinta_iot_webrtc_v1_management: GenFile;
  * stronger request than it looks: there is no parent whose reach could authorize
  * it, so it is reserved to the gateway's administrator.
  *
+ * Under an apartment only a room may be created. Creating in a home is guarded as
+ * UpdateSpace is, and refused whatever the caller where UpdateSpace's structure rules would
+ * refuse it.
+ *
  * @generated from message kusinta.iot.webrtc.v1.CreateSpace
  */
 export declare type CreateSpace = Message<"kusinta.iot.webrtc.v1.CreateSpace"> & {
@@ -49,6 +61,14 @@ export declare type CreateSpace = Message<"kusinta.iot.webrtc.v1.CreateSpace"> &
    * @generated from field: kusinta.iot.identity.v1.SpaceId parent_space_id = 5;
    */
   parentSpaceId?: SpaceId | undefined;
+
+  /**
+   * An IANA time zone name, e.g. "Europe/Stockholm". Accepted only on a building — a
+   * top-level space — and refused on any other. Unset leaves it unknown.
+   *
+   * @generated from field: optional string time_zone = 6;
+   */
+  timeZone?: string | undefined;
 };
 
 /**
@@ -58,9 +78,21 @@ export declare type CreateSpace = Message<"kusinta.iot.webrtc.v1.CreateSpace"> &
 export declare const CreateSpaceSchema: GenMessage<CreateSpace>;
 
 /**
- * Changes a space in place. Every descriptive field carries explicit presence:
- * absent means leave it alone, present means set it to this — including to the
- * empty string, which is how a description is cleared.
+ * Changes a space in place. Changes that would take a space into or out of a home, or move
+ * a home, are guarded by the gateway; a caller not allowed is refused as NOT_ENTITLED. A
+ * change is refused whatever the caller if it would leave anything but a room under an
+ * apartment, an apartment in a home, or — among what the caller can see — a device in two
+ * homes or a link across a home's boundary. What the caller cannot see never refuses it: a
+ * device a resident owns that would leave its owner's home, enter a home not theirs or sit
+ * in two homes is taken out of the moving space instead — staying in its owner's home,
+ * filed on the apartment, where it was in it — and any link it would carry across a
+ * boundary is removed. Changing the type of a space that has members needs
+ * ROLE_PROPERTY_OWNER or ROLE_GATEWAY_ADMIN, who see them, and is refused if it would
+ * leave a RESIDENT membership on a room.
+ *
+ * Every descriptive field carries explicit presence: absent means leave it alone, present
+ * means set it to this — including to the empty string, which is how a description is
+ * cleared.
  *
  * @generated from message kusinta.iot.webrtc.v1.UpdateSpace
  */
@@ -111,6 +143,15 @@ export declare type UpdateSpace = Message<"kusinta.iot.webrtc.v1.UpdateSpace"> &
     value: boolean;
     case: "detach";
   } | { case: undefined; value?: undefined };
+
+  /**
+   * An IANA time zone name, e.g. "Europe/Stockholm". Accepted only on a building — a
+   * top-level space — and refused on any other. Unset leaves it unchanged; the empty
+   * string clears it.
+   *
+   * @generated from field: optional string time_zone = 8;
+   */
+  timeZone?: string | undefined;
 };
 
 /**
@@ -122,7 +163,8 @@ export declare const UpdateSpaceSchema: GenMessage<UpdateSpace>;
 /**
  * Deletes a space. Refused if the space still holds devices or sub-spaces unless
  * cascade is set, so that emptying a building is always something the caller
- * asked for rather than something a stale client did by accident.
+ * asked for rather than something a stale client did by accident. Deleting a home, or
+ * anything in one, is guarded as UpdateSpace is.
  *
  * @generated from message kusinta.iot.webrtc.v1.DeleteSpace
  */
@@ -145,10 +187,17 @@ export declare type DeleteSpace = Message<"kusinta.iot.webrtc.v1.DeleteSpace"> &
 export declare const DeleteSpaceSchema: GenMessage<DeleteSpace>;
 
 /**
- * Adds a user to a space, granting them reach of it and everything beneath it.
+ * Adds a user to a space, granting them reach of it and everything beneath it — except
+ * that a RESIDENT membership reaches no home beneath it (see access.v1.MembershipRelation).
  * The user need not be known to the gateway beforehand — identities are minted by
  * the token issuer, and this records that one of them belongs here.
  *
+ * Assigning a user who is already a member changes their relation to the space.
+ * RESIDENT is refused on a room; see access.v1.MembershipRelation.
+ *
+ * Who may change who belongs to a home is restricted by the gateway; a caller not allowed is
+ * refused as NOT_ENTITLED. Residents see who is filed on their home in Space.members.
+ *
  * @generated from message kusinta.iot.webrtc.v1.AssignUserToSpace
  */
 export declare type AssignUserToSpace = Message<"kusinta.iot.webrtc.v1.AssignUserToSpace"> & {
@@ -161,6 +210,15 @@ export declare type AssignUserToSpace = Message<"kusinta.iot.webrtc.v1.AssignUse
    * @generated from field: kusinta.iot.identity.v1.UserId user_id = 2;
    */
   userId?: UserId | undefined;
+
+  /**
+   * How the user stands to the space — whether they live there or are there for the
+   * building. Required: UNSPECIFIED is refused, never defaulted. See
+   * access.v1.MembershipRelation for what each lets a member see of a home.
+   *
+   * @generated from field: kusinta.iot.access.v1.MembershipRelation relation = 4;
+   */
+  relation: MembershipRelation;
 };
 
 /**
@@ -173,6 +231,8 @@ export declare const AssignUserToSpaceSchema: GenMessage<AssignUserToSpace>;
  * Removes a user's membership of a space. Losing reach also drops whatever the
  * user was streaming from it, announced by LivePermissionUpdate.
  *
+ * Removing someone else from a home is guarded as assigning is.
+ *
  * @generated from message kusinta.iot.webrtc.v1.RemoveUserFromSpace
  */
 export declare type RemoveUserFromSpace = Message<"kusinta.iot.webrtc.v1.RemoveUserFromSpace"> & {
@@ -197,6 +257,12 @@ export declare const RemoveUserFromSpaceSchema: GenMessage<RemoveUserFromSpace>;
  * Files a device into a space. A device may sit in several spaces at once; this
  * is additive, and filing a device where it already sits is a no-op.
  *
+ * Into a home go only the building's own devices and devices its residents own, and a
+ * device belongs to one home at most; filing into, out of or beside a home is guarded by
+ * the gateway. A caller not allowed is refused as NOT_ENTITLED, and filing that would leave
+ * a link the caller can see across a home's boundary is refused whatever the caller; one
+ * they cannot see is removed instead.
+ *
  * @generated from message kusinta.iot.webrtc.v1.PlaceDeviceInSpace
  */
 export declare type PlaceDeviceInSpace = Message<"kusinta.iot.webrtc.v1.PlaceDeviceInSpace"> & {
@@ -221,6 +287,9 @@ export declare const PlaceDeviceInSpaceSchema: GenMessage<PlaceDeviceInSpace>;
  * Takes a device out of one space, leaving any others intact. A device in no
  * space and with no owner is unfiled, and visible only to the administrator.
  *
+ * Taking a device out of a home is guarded as PlaceDeviceInSpace is, and removes its links
+ * to devices still in the home.
+ *
  * @generated from message kusinta.iot.webrtc.v1.RemoveDeviceFromSpace
  */
 export declare type RemoveDeviceFromSpace = Message<"kusinta.iot.webrtc.v1.RemoveDeviceFromSpace"> & {
@@ -244,7 +313,12 @@ export declare const RemoveDeviceFromSpaceSchema: GenMessage<RemoveDeviceFromSpa
 /**
  * Takes ownership of a device. Ownership is reach in its own right: an owner may
  * see and control their device whatever their gateway-wide role permits, and may
- * file it into spaces they belong to.
+ * file it into spaces they belong to, and the rooms of a home they live in — though into a
+ * home only if they live there (see PlaceDeviceInSpace).
+ *
+ * Only a RESIDENT claim makes the caller the owner. A COMPANY claim records that the
+ * building owns the device, names no person, and grants the caller no reach. Claims of a
+ * device in a home, or of one already claimed, are restricted by the gateway.
  *
  * @generated from message kusinta.iot.webrtc.v1.ClaimDevice
  */
@@ -265,8 +339,18 @@ export declare type ClaimDevice = Message<"kusinta.iot.webrtc.v1.ClaimDevice"> &
   initialSpaceId?: SpaceId | undefined;
 
   /**
-   * Evidence the claimant is standing at the device: the serial printed on it,
-   * matched against DeviceDescriptor.serial_number. Required precisely when the
+   * Evidence the claimant is standing at the device: the identifier printed on it,
+   * matched against DeviceDescriptor.serial_number.
+   *
+   * The match is by SUFFIX, because what a connector announces is not always the whole
+   * of what is printed and the announced value is commonly the tail of the printed one.
+   * Both sides are normalised first — lowercased, with whitespace and ASCII hyphens
+   * removed, since a label prints the value in groups and a scan does not — and the proof
+   * is accepted when what remains ends with the announced serial. Spelled out because two
+   * gateways normalising differently would accept different proofs for the same device.
+   *
+   * A serial shorter than eight characters cannot be proved at all: under a suffix rule a
+   * short one is proved by almost anything ending with it. Required precisely when the
    * caller cannot already reach the device, which is the ordinary case for a
    * resident claiming something they just bought — an unfiled device is invisible
    * to them, so possession is the only thing left that can distinguish them from
@@ -286,8 +370,9 @@ export declare type ClaimDevice = Message<"kusinta.iot.webrtc.v1.ClaimDevice"> &
 export declare const ClaimDeviceSchema: GenMessage<ClaimDevice>;
 
 /**
- * Gives up ownership. The device keeps whatever space filing it has; if it has
- * none it becomes unfiled.
+ * Gives up ownership. The device keeps whatever space filing it has, except that a device in
+ * a home stays filed in the home alone, as one of the building's own devices there — as
+ * when its owner moves out; if it has none it becomes unfiled.
  *
  * @generated from message kusinta.iot.webrtc.v1.ReleaseDevice
  */
@@ -304,6 +389,66 @@ export declare type ReleaseDevice = Message<"kusinta.iot.webrtc.v1.ReleaseDevice
  */
 export declare const ReleaseDeviceSchema: GenMessage<ReleaseDevice>;
 
+/**
+ * Registers a device with the system that will admit it, so that it can join
+ * later. For a technology where a device is enrolled as a record rather than
+ * adopted during a window — see common.v1.PairingWindow for the other case, where
+ * something joins a hub during a window and the arrival is attributed to the
+ * caller. A LoRaWAN device has no window: it is written into a network server and
+ * joins whenever it is next powered, which may be minutes, days, or never.
+ *
+ * Answered with the ordinary ManagementAck. A provision writes a record and returns
+ * nothing to show; the device itself is announced by device_added if and when it
+ * joins, the same path every other device takes — which is why this adds no
+ * ManagementResult arm. A new result arm is a compile error in a consumer that
+ * matches the result exhaustively; a new request arm is not.
+ *
+ * Registering and owning stay two operations. ClaimDevice records the caller and
+ * carries possession_proof, so a device that has not joined yet is still claimable
+ * by whoever holds it — and because the connector derives the device id and the
+ * serial from the identifier here, that claim can be made before the join.
+ *
+ * Provisioning the same identifier twice is an upsert: it replaces the credentials
+ * rather than being refused as a conflict, so correcting a mistyped key does not
+ * require removing the device first. Removing a record is a distinct act from
+ * giving up ownership (ReleaseDevice) and is left to a later operation.
+ *
+ * @generated from message kusinta.iot.webrtc.v1.ProvisionDevice
+ */
+export declare type ProvisionDevice = Message<"kusinta.iot.webrtc.v1.ProvisionDevice"> & {
+  /**
+   * Required, unlike a pairing window's connector target. A registration is written
+   * to one specific registry; there is no sensible "open them all and see what
+   * joins". The app names it from the connector enumeration, targeting a connector
+   * that declares ConnectorInfo.supports_provisioning.
+   *
+   * @generated from field: kusinta.iot.identity.v1.ConnectorId connector_id = 1;
+   */
+  connectorId?: ConnectorId | undefined;
+
+  /**
+   * What the registry needs to admit the device, which differs entirely by
+   * technology — a oneof per technology rather than a flat set of fields, for the
+   * reason LinkSettings gives: the second technology to arrive must not turn this
+   * into a bag of unrelated optionals named after the first.
+   *
+   * @generated from oneof kusinta.iot.webrtc.v1.ProvisionDevice.credentials
+   */
+  credentials: {
+    /**
+     * @generated from field: kusinta.iot.vendor.lorawan.v1.LorawanProvisioning lorawan = 2;
+     */
+    value: LorawanProvisioning;
+    case: "lorawan";
+  } | { case: undefined; value?: undefined };
+};
+
+/**
+ * Describes the message kusinta.iot.webrtc.v1.ProvisionDevice.
+ * Use `create(ProvisionDeviceSchema)` to create a new message.
+ */
+export declare const ProvisionDeviceSchema: GenMessage<ProvisionDevice>;
+
 /**
  * Asks for the spaces the caller can reach. Unset root_space_id means all of
  * them, which for most users is one apartment and for an administrator is the
@@ -333,7 +478,9 @@ export declare const ListSpacesSchema: GenMessage<ListSpaces>;
  *
  * device_ids on each Space are filtered to what the caller may see. An
  * unfiltered tree would list every device on the gateway by id, which is the
- * enumeration channel the snapshot filter exists to close.
+ * enumeration channel the snapshot filter exists to close. To a caller who sees a home as
+ * service, what is new in it is listed as it happens and what is gone at once, its members
+ * included where they are shown (see Space.members).
  *
  * @generated from message kusinta.iot.webrtc.v1.SpaceTree
  */
@@ -373,7 +520,671 @@ export declare const ManagementAckSchema: GenMessage<ManagementAck>;
  * message kind, so these can never be gated by a table keyed on the envelope case
  * the way device messages are. Keeping them behind one case means one place that
  * must authorize, and one refusal path that must not leak whether a target exists.
+ * Links one device to another, so the sender leads the receiver. The gateway
+ * resolves which underlying connections that needs and asks the connector for
+ * them; a caller names two devices and what the link is for.
+ *
+ * Authorized against both ends, and not symmetrically. Leading a device is a
+ * standing grant of control over it, so the receiver requires ownership or a
+ * servicing role. The sender's requirement depends on the mode: a gateway-kept
+ * link only reads what the caller can already see, while a device-to-device one
+ * writes configuration to the sender and spends its battery, which is a change
+ * to someone else's hardware.
+ *
+ * In a home it is the other way round: links between its devices are its residents' to
+ * make, change and remove, and a caller who reaches it as service is refused as
+ * NOT_ENTITLED. A link between a device in a home and one outside it is refused to anyone.
+ * The same holds for UpdateDeviceLink and RemoveDeviceLink.
+ *
+ * @generated from message kusinta.iot.webrtc.v1.CreateDeviceLink
+ */
+export declare type CreateDeviceLink = Message<"kusinta.iot.webrtc.v1.CreateDeviceLink"> & {
+  /**
+   * @generated from field: kusinta.iot.identity.v1.DeviceId sender = 1;
+   */
+  sender?: DeviceId | undefined;
+
+  /**
+   * @generated from field: kusinta.iot.identity.v1.DeviceId receiver = 2;
+   */
+  receiver?: DeviceId | undefined;
+
+  /**
+   * @generated from field: kusinta.iot.link.v1.LinkFunction function = 3;
+   */
+  function: LinkFunction;
+
+  /**
+   * Unset lets the gateway choose, which prefers a device-to-device link where
+   * one can be brokered: it survives a gateway outage and runs at the devices'
+   * own rate. Name one to override that.
+   *
+   * @generated from field: kusinta.iot.link.v1.LinkMode mode = 4;
+   */
+  mode: LinkMode;
+
+  /**
+   * How a gateway-kept link is to behave, set as it is made. Carried here as
+   * well as on UpdateDeviceLink so that a link does not have to exist in a
+   * configured-by-nobody state first — a soft climate link created without a
+   * target is one that holds the room at nothing until a second request
+   * arrives, and every reader would have to handle that transient forever.
+   *
+   * Unset is still allowed and still means unconfigured, since a hard link has
+   * nothing to configure and a caller may genuinely not know the target yet.
+   *
+   * @generated from field: kusinta.iot.link.v1.LinkSettings settings = 5;
+   */
+  settings?: LinkSettings | undefined;
+};
+
+/**
+ * Describes the message kusinta.iot.webrtc.v1.CreateDeviceLink.
+ * Use `create(CreateDeviceLinkSchema)` to create a new message.
+ */
+export declare const CreateDeviceLinkSchema: GenMessage<CreateDeviceLink>;
+
+/**
+ * Removes a link. Note that on at least one vendor, removing a link disturbs the
+ * receiver's own settings and the connector must repair them, so this is not the
+ * no-op it appears to be.
+ *
+ * @generated from message kusinta.iot.webrtc.v1.RemoveDeviceLink
+ */
+export declare type RemoveDeviceLink = Message<"kusinta.iot.webrtc.v1.RemoveDeviceLink"> & {
+  /**
+   * @generated from field: string link_id = 1;
+   */
+  linkId: string;
+};
+
+/**
+ * Describes the message kusinta.iot.webrtc.v1.RemoveDeviceLink.
+ * Use `create(RemoveDeviceLinkSchema)` to create a new message.
+ */
+export declare const RemoveDeviceLinkSchema: GenMessage<RemoveDeviceLink>;
+
+/**
+ * Changes how a gateway-kept link behaves — for a climate lead, the temperature
+ * it is to hold.
+ *
+ * Refused on a link that has nothing to configure — see LinkSettings — rather
+ * than accepted as a no-op, so that a caller who has mistaken which link they
+ * are holding is told.
+ *
+ * Authorized against both ends, as creating and removing the link are: deciding
+ * what temperature a room is held at is directing a device, not adjusting one,
+ * so it takes ownership of the ends or a servicing role, not the permission to
+ * turn a thermostat up. In a home it is its residents' instead (see CreateDeviceLink).
+ *
+ * @generated from message kusinta.iot.webrtc.v1.UpdateDeviceLink
+ */
+export declare type UpdateDeviceLink = Message<"kusinta.iot.webrtc.v1.UpdateDeviceLink"> & {
+  /**
+   * @generated from field: string link_id = 1;
+   */
+  linkId: string;
+
+  /**
+   * Replaces the link's settings rather than patching them: the settings of one
+   * function are few and are set together, so there is no half-update worth
+   * expressing. This is why it does not follow UpdateSpace's per-field optional
+   * shape, which exists for a message whose fields genuinely move alone.
+   *
+   * Unset is refused rather than being given a meaning. It would have to mean
+   * either "leave everything alone", making the request a no-op, or "clear the
+   * settings", which is the one thing that reads like an accident — and the
+   * wire cannot tell those two callers apart.
+   *
+   * @generated from field: kusinta.iot.link.v1.LinkSettings settings = 2;
+   */
+  settings?: LinkSettings | undefined;
+};
+
+/**
+ * Describes the message kusinta.iot.webrtc.v1.UpdateDeviceLink.
+ * Use `create(UpdateDeviceLinkSchema)` to create a new message.
+ */
+export declare const UpdateDeviceLinkSchema: GenMessage<UpdateDeviceLink>;
+
+/**
+ * Lists links. Unset device_id lists every link among devices the caller can
+ * reach; naming one narrows it to that device's own, in either direction.
+ *
+ * A link with an end in a home reaches a caller who sees it as service with
+ * DeviceLink.details_withheld set, and what that withholds unset — a new link
+ * as it is made, a removed one at once — and not at all when either end is a
+ * device a resident owns.
+ *
+ * @generated from message kusinta.iot.webrtc.v1.ListDeviceLinks
+ */
+export declare type ListDeviceLinks = Message<"kusinta.iot.webrtc.v1.ListDeviceLinks"> & {
+  /**
+   * @generated from field: kusinta.iot.identity.v1.DeviceId device_id = 1;
+   */
+  deviceId?: DeviceId | undefined;
+};
+
+/**
+ * Describes the message kusinta.iot.webrtc.v1.ListDeviceLinks.
+ * Use `create(ListDeviceLinksSchema)` to create a new message.
+ */
+export declare const ListDeviceLinksSchema: GenMessage<ListDeviceLinks>;
+
+/**
+ * Sets the temperature a room is to be held at.
+ *
+ * Authorized as adjusting, not directing: WRITE on the room is enough. It is the same act
+ * as turning a radiator's knob; setting up what the room obeys is ConfigureRoomClimate,
+ * and stays with owners, except the lock in a home.
+ *
+ * In a home, only its residents may set it; a caller who reaches the room as service is
+ * refused as NOT_ENTITLED.
+ *
+ * Clamped to the room's limits rather than refused outside them, and the clamped value is
+ * what the room's RoomClimate then reports.
+ *
+ * @generated from message kusinta.iot.webrtc.v1.SetRoomTarget
+ */
+export declare type SetRoomTarget = Message<"kusinta.iot.webrtc.v1.SetRoomTarget"> & {
+  /**
+   * @generated from field: kusinta.iot.identity.v1.SpaceId room_id = 1;
+   */
+  roomId?: SpaceId | undefined;
+
+  /**
+   * Unset clears the target: the room goes back to having none (NO_TARGET) and its
+   * devices to their own behaviour. With presence, so that a request that forgot the
+   * field is not read as 0 °C and clamped to the room's minimum.
+   *
+   * @generated from field: optional sint32 target_centidegrees = 2;
+   */
+  targetCentidegrees?: number | undefined;
+};
+
+/**
+ * Describes the message kusinta.iot.webrtc.v1.SetRoomTarget.
+ * Use `create(SetRoomTargetSchema)` to create a new message.
+ */
+export declare const SetRoomTargetSchema: GenMessage<SetRoomTarget>;
+
+/**
+ * The sensors a room measures with, in order of preference. A message of its own so that
+ * "leave the sensors alone" (unset) differs from "set" on the wire. It orders the
+ * building's sensors only (see climate.v1.RoomClimate.sensor_ids); set but empty returns
+ * them to the default, every building temperature sensor filed in the room in filing
+ * order.
+ *
+ * @generated from message kusinta.iot.webrtc.v1.RoomSensors
+ */
+export declare type RoomSensors = Message<"kusinta.iot.webrtc.v1.RoomSensors"> & {
+  /**
+   * @generated from field: repeated kusinta.iot.identity.v1.DeviceId sensor_ids = 1;
+   */
+  sensorIds: DeviceId[];
+};
+
+/**
+ * Describes the message kusinta.iot.webrtc.v1.RoomSensors.
+ * Use `create(RoomSensorsSchema)` to create a new message.
+ */
+export declare const RoomSensorsSchema: GenMessage<RoomSensors>;
+
+/**
+ * A room's limits. A message of its own so that "leave the limits alone" (unset) differs
+ * from "set" — and, set, an unset bound inside it removes that bound, which a bare
+ * optional on the request could not say.
+ *
+ * @generated from message kusinta.iot.webrtc.v1.RoomLimits
+ */
+export declare type RoomLimits = Message<"kusinta.iot.webrtc.v1.RoomLimits"> & {
+  /**
+   * @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.webrtc.v1.RoomLimits.
+ * Use `create(RoomLimitsSchema)` to create a new message.
+ */
+export declare const RoomLimitsSchema: GenMessage<RoomLimits>;
+
+/**
+ * Configures what a room obeys: its limits, its sensors, and whether a change made by
+ * hand at one of its devices counts. Authorized as directing — owners and filing roles —
+ * because this decides what everybody in the room can do.
+ *
+ * One exception: in a home, lock_device_controls is its residents' alone. They may send
+ * this request with nothing else set. Outside homes the lock is the owner's, as the rest
+ * is. A request that sets anything its caller may not — the lock in a home for service;
+ * anything but the lock in a home, or the lock outside one, for a caller with neither
+ * ROLE_PROPERTY_OWNER nor a filing role — is refused whole as NOT_ENTITLED, so nothing of
+ * it applies. sensors orders only the building's own
+ * sensors (see RoomClimate.sensor_ids).
+ *
+ * Each field moves alone, as on UpdateSpace: unset leaves it as it is.
+ *
+ * @generated from message kusinta.iot.webrtc.v1.ConfigureRoomClimate
+ */
+export declare type ConfigureRoomClimate = Message<"kusinta.iot.webrtc.v1.ConfigureRoomClimate"> & {
+  /**
+   * @generated from field: kusinta.iot.identity.v1.SpaceId room_id = 1;
+   */
+  roomId?: SpaceId | undefined;
+
+  /**
+   * Replaces both bounds; see RoomLimits.
+   *
+   * @generated from field: kusinta.iot.webrtc.v1.RoomLimits limits = 2;
+   */
+  limits?: RoomLimits | undefined;
+
+  /**
+   * Only the building's sensors filed in this room; any other — including a sensor a
+   * resident owns — is refused, the same way whether or not it exists.
+   *
+   * @generated from field: kusinta.iot.webrtc.v1.RoomSensors sensors = 3;
+   */
+  sensors?: RoomSensors | undefined;
+
+  /**
+   * @generated from field: optional bool lock_device_controls = 4;
+   */
+  lockDeviceControls?: boolean | undefined;
+};
+
+/**
+ * Describes the message kusinta.iot.webrtc.v1.ConfigureRoomClimate.
+ * Use `create(ConfigureRoomClimateSchema)` to create a new message.
+ */
+export declare const ConfigureRoomClimateSchema: GenMessage<ConfigureRoomClimate>;
+
+/**
+ * Switches a mode on a space on, or off with kind UNSPECIFIED. WRITE on the space.
+ * Switching one on needs setback_centidegrees; a mode with nothing to set back to is
+ * refused. Switching one on is refused on a room inside an apartment, whose rooms follow
+ * the apartment's mode alone; such a room carries none (see climate.v1.ClimateMode), and
+ * switching one off there is accepted and does nothing — for those who may switch modes in
+ * that home at all, which is checked first: anyone else is refused as NOT_ENTITLED.
+ *
+ * In a home, only its residents may switch one on or off: whether a home stands empty is
+ * theirs to say. A caller who reaches it as service is refused as NOT_ENTITLED — except
+ * that, while the home has no resident, ROLE_PROPERTY_OWNER or ROLE_GATEWAY_ADMIN may
+ * switch off a mode that is on and whose setter is not a resident, so that no mode
+ * outlives everyone who could end it. Any other switch-off from them — no mode on, or one
+ * that is a resident's — is accepted and does nothing, so the answer tells them nothing of
+ * whether a mode was on or whether anyone has moved in.
+ *
+ * @generated from message kusinta.iot.webrtc.v1.SetClimateMode
+ */
+export declare type SetClimateMode = Message<"kusinta.iot.webrtc.v1.SetClimateMode"> & {
+  /**
+   * @generated from field: kusinta.iot.identity.v1.SpaceId space_id = 1;
+   */
+  spaceId?: SpaceId | undefined;
+
+  /**
+   * @generated from field: kusinta.iot.climate.v1.ClimateModeKind kind = 2;
+   */
+  kind: ClimateModeKind;
+
+  /**
+   * @generated from field: optional sint32 setback_centidegrees = 3;
+   */
+  setbackCentidegrees?: number | undefined;
+
+  /**
+   * HOLIDAY only; both required there. Refused on AWAY.
+   *
+   * @generated from field: google.protobuf.Timestamp starts_at = 4;
+   */
+  startsAt?: Timestamp | undefined;
+
+  /**
+   * @generated from field: google.protobuf.Timestamp ends_at = 5;
+   */
+  endsAt?: Timestamp | undefined;
+};
+
+/**
+ * Describes the message kusinta.iot.webrtc.v1.SetClimateMode.
+ * Use `create(SetClimateModeSchema)` to create a new message.
+ */
+export declare const SetClimateModeSchema: GenMessage<SetClimateMode>;
+
+/**
+ * Lists the room climates and modes a caller may see. Unset root_space_id lists every
+ * one the caller can reach; naming a space narrows it to that space and those below.
+ *
+ * A caller who reaches a room inside an apartment as service gets it with
+ * RoomClimate.state_withheld set — what is new as it happens, what is gone at once — and
+ * gets no ClimateMode set on that apartment or its rooms.
  *
+ * @generated from message kusinta.iot.webrtc.v1.ListRoomClimates
+ */
+export declare type ListRoomClimates = Message<"kusinta.iot.webrtc.v1.ListRoomClimates"> & {
+  /**
+   * @generated from field: kusinta.iot.identity.v1.SpaceId root_space_id = 1;
+   */
+  rootSpaceId?: SpaceId | undefined;
+};
+
+/**
+ * Describes the message kusinta.iot.webrtc.v1.ListRoomClimates.
+ * Use `create(ListRoomClimatesSchema)` to create a new message.
+ */
+export declare const ListRoomClimatesSchema: GenMessage<ListRoomClimates>;
+
+/**
+ * Reads a room's history, answered with a climate.v1.RoomHistory of fixed 15-minute
+ * buckets aligned to UTC quarter hours (:00, :15, :30, :45). Needs READ on the room.
+ *
+ * The range is half-open: a bucket is returned when from_time <= at < to_time, so
+ * back-to-back windows neither repeat nor skip a bucket. Unset to_time means now;
+ * unset from_time means RoomHistory.kept_from. Both are clamped to [kept_from, now].
+ *
+ * A room in a home is readable by its residents only, and only from the start of their
+ * current residency (see access.v1.MembershipRelation). A caller who reaches it as service is
+ * refused as NOT_ENTITLED; one who reaches the apartment itself has
+ * GetApartmentClimateSummary instead.
+ *
+ * @generated from message kusinta.iot.webrtc.v1.GetRoomHistory
+ */
+export declare type GetRoomHistory = Message<"kusinta.iot.webrtc.v1.GetRoomHistory"> & {
+  /**
+   * @generated from field: kusinta.iot.identity.v1.SpaceId room_id = 1;
+   */
+  roomId?: SpaceId | undefined;
+
+  /**
+   * @generated from field: google.protobuf.Timestamp from_time = 2;
+   */
+  fromTime?: Timestamp | undefined;
+
+  /**
+   * @generated from field: google.protobuf.Timestamp to_time = 3;
+   */
+  toTime?: Timestamp | undefined;
+};
+
+/**
+ * Describes the message kusinta.iot.webrtc.v1.GetRoomHistory.
+ * Use `create(GetRoomHistorySchema)` to create a new message.
+ */
+export declare const GetRoomHistorySchema: GenMessage<GetRoomHistory>;
+
+/**
+ * What the parties who do not live in a private space learn of it — the answer to a
+ * resident asking who can see what in their home, in reply to GetPrivacyDisclosure.
+ *
+ * It states the policy, the kinds of party it applies to now and the people counted under
+ * each (ServiceParty.names): a resident learns which technicians can see the battery of
+ * their radiator valve. The names say who has reach, never where anyone lives.
+ *
+ * @generated from message kusinta.iot.webrtc.v1.PrivacyDisclosure
+ */
+export declare type PrivacyDisclosure = Message<"kusinta.iot.webrtc.v1.PrivacyDisclosure"> & {
+  /**
+   * An apartment, or a room in one.
+   *
+   * @generated from field: kusinta.iot.identity.v1.SpaceId space_id = 1;
+   */
+  spaceId?: SpaceId | undefined;
+
+  /**
+   * The kinds of party who see this space, or any part of it, as service now — or would
+   * through another membership, were they not its residents — each role once, with what
+   * that role brings here. Each party is listed under every role it holds other than
+   * ROLE_RESIDENT, and sees what its entries say together; one with no other role, or whose
+   * role the gateway has not yet learnt, counts as ROLE_UNSPECIFIED. ROLE_GATEWAY_ADMIN is
+   * always listed, and ROLE_PROPERTY_OWNER whenever anyone holds it, wherever they are
+   * filed: both may file themselves on the home. So the list reads the same whether or not
+   * anyone lives in the home, and never understates who has reach or what they see. Devices a resident
+   * owns are not shown to service at all.
+   *
+   * @generated from field: repeated kusinta.iot.webrtc.v1.ServiceParty service_parties = 5;
+   */
+  serviceParties: ServiceParty[];
+
+  /**
+   * How finely the space's climate is summarised for service, as means over periods of
+   * this length (climate.v1.ApartmentClimateSummary). UNSPECIFIED: no summary is given.
+   * The gateway's own setting, WEEK unless it is configured otherwise; no operation in this
+   * contract changes it. A change applies to periods that open after it: service is given
+   * no period that opened before the last change.
+   *
+   * @generated from field: kusinta.iot.climate.v1.ClimateSummaryPeriod climate_summary_period = 4;
+   */
+  climateSummaryPeriod: ClimateSummaryPeriod;
+
+  /**
+   * The name of the organisation that owns the property, when one is recorded
+   * (SetOwnerOrganisation). Its organisation number is not given here.
+   *
+   * @generated from field: string owner_organisation_name = 6;
+   */
+  ownerOrganisationName: string;
+
+  /**
+   * Set when ServiceParty.names are not given to this caller, so that empty lists are not
+   * read as nobody being named. Names are given to the home's own residents and to a
+   * caller holding ROLE_GATEWAY_ADMIN or ROLE_PROPERTY_OWNER, and withheld from anyone
+   * else: a technician who reaches the home learns the kinds of party, not who they are.
+   *
+   * @generated from field: bool names_withheld = 7;
+   */
+  namesWithheld: boolean;
+};
+
+/**
+ * Describes the message kusinta.iot.webrtc.v1.PrivacyDisclosure.
+ * Use `create(PrivacyDisclosureSchema)` to create a new message.
+ */
+export declare const PrivacyDisclosureSchema: GenMessage<PrivacyDisclosure>;
+
+/**
+ * One kind of party with service reach of a home, and what it sees there. Every service
+ * party sees the same kinds of thing of the part of the home it reaches — a whole
+ * ServiceStatus, nothing withheld from it — so signals differ between parties only in
+ * RESIDENTS. How much of the home that part is, a room or all of it, the disclosure does
+ * not say.
+ *
+ * @generated from message kusinta.iot.webrtc.v1.ServiceParty
+ */
+export declare type ServiceParty = Message<"kusinta.iot.webrtc.v1.ServiceParty"> & {
+  /**
+   * @generated from field: kusinta.iot.access.v1.Role role = 1;
+   */
+  role: Role;
+
+  /**
+   * @generated from field: repeated kusinta.iot.access.v1.ServiceSignal signals = 2;
+   */
+  signals: ServiceSignal[];
+
+  /**
+   * Each person counted under this role, by the name they gave their account
+   * (AppTokenClaims.name), once each: everyone holding ROLE_GATEWAY_ADMIN or
+   * ROLE_PROPERTY_OWNER, the registering administrator included once the gateway has seen
+   * their token, and everyone else counted here by a SERVICE membership. A person counted
+   * under several roles is named under each. An empty string stands for a person whose name
+   * the gateway has not learnt, so the list is as long as the number of people. Self-chosen,
+   * so the app shows it as the name they gave rather than as a verified identity. Empty for
+   * every party when PrivacyDisclosure.names_withheld is set.
+   *
+   * @generated from field: repeated string names = 3;
+   */
+  names: string[];
+};
+
+/**
+ * Describes the message kusinta.iot.webrtc.v1.ServiceParty.
+ * Use `create(ServicePartySchema)` to create a new message.
+ */
+export declare const ServicePartySchema: GenMessage<ServiceParty>;
+
+/**
+ * Asks what the parties who do not live in a space learn of it, answered with a
+ * PrivacyDisclosure. For an apartment or a room in one, and refused on any other
+ * space. Needs READ on the space.
+ *
+ * @generated from message kusinta.iot.webrtc.v1.GetPrivacyDisclosure
+ */
+export declare type GetPrivacyDisclosure = Message<"kusinta.iot.webrtc.v1.GetPrivacyDisclosure"> & {
+  /**
+   * @generated from field: kusinta.iot.identity.v1.SpaceId space_id = 1;
+   */
+  spaceId?: SpaceId | undefined;
+};
+
+/**
+ * Describes the message kusinta.iot.webrtc.v1.GetPrivacyDisclosure.
+ * Use `create(GetPrivacyDisclosureSchema)` to create a new message.
+ */
+export declare const GetPrivacyDisclosureSchema: GenMessage<GetPrivacyDisclosure>;
+
+/**
+ * Reads an apartment's climate as means over whole periods, answered with a
+ * climate.v1.ApartmentClimateSummary. Needs READ on the apartment itself. Refused on a
+ * space that is not an apartment, and while the building's time zone (Space.time_zone) is
+ * unknown, since periods are cut at its midnights.
+ *
+ * The range is half-open over the periods' starts: a period is returned when from_time <=
+ * starts_at < to_time. Unset from_time means kept_from; unset to_time means now. Both are
+ * clamped to [kept_from, the start of the period running now — or now, if none is] (see
+ * ApartmentClimateSummary).
+ *
+ * @generated from message kusinta.iot.webrtc.v1.GetApartmentClimateSummary
+ */
+export declare type GetApartmentClimateSummary = Message<"kusinta.iot.webrtc.v1.GetApartmentClimateSummary"> & {
+  /**
+   * @generated from field: kusinta.iot.identity.v1.SpaceId apartment_id = 1;
+   */
+  apartmentId?: SpaceId | undefined;
+
+  /**
+   * Unset asks for the period the apartment's privacy disclosure names
+   * (PrivacyDisclosure.climate_summary_period), or weeks when it names none. Anyone but the
+   * apartment's residents may ask for that period only, and is refused as NOT_ENTITLED for
+   * any other or when it names none. Its residents may ask for any, and are given only
+   * periods that began in their current residency.
+   *
+   * @generated from field: kusinta.iot.climate.v1.ClimateSummaryPeriod period = 2;
+   */
+  period: ClimateSummaryPeriod;
+
+  /**
+   * @generated from field: google.protobuf.Timestamp from_time = 3;
+   */
+  fromTime?: Timestamp | undefined;
+
+  /**
+   * @generated from field: google.protobuf.Timestamp to_time = 4;
+   */
+  toTime?: Timestamp | undefined;
+};
+
+/**
+ * Describes the message kusinta.iot.webrtc.v1.GetApartmentClimateSummary.
+ * Use `create(GetApartmentClimateSummarySchema)` to create a new message.
+ */
+export declare const GetApartmentClimateSummarySchema: GenMessage<GetApartmentClimateSummary>;
+
+/**
+ * Asks the gateway to have a connector re-initialise its backend connection: reconnect to
+ * its radio central or network server. Meant to be offered while a
+ * reporting.v1.PROBLEM_KIND_CONNECTOR_ERROR is open for the connector — its
+ * ConnectorDescriptor.backend_health is FAILING — and only for a connector listed in
+ * ConnectorsAnnounced. A request for a connector that is not listed is refused, as
+ * CONNECTOR_OFFLINE or UNKNOWN_CONNECTOR below. For a listed one it is accepted whatever its
+ * health, since re-initialising a healthy backend is harmless.
+ *
+ * Authorized against the caller's role alone, as StartPairing is: a connector is not a
+ * target the caller reaches the way a space is. ROLE_TECHNICIAN and ROLE_GATEWAY_ADMIN may
+ * ask; anyone else is refused as NOT_ENTITLED, before the connector is looked up, so the
+ * refusal says nothing of which connectors exist.
+ *
+ * The gateway forwards it as connector.v1.ReinitializeBackend and answers once the
+ * connector has: with ManagementAck when the attempt was made. That says the attempt
+ * finished, not that it worked. Whether it worked is the connector's backend health, and
+ * when that changed the gateway pushes it in ConnectorsAnnounced before the ack. One
+ * request at a time per connector.
+ *
+ * So a failure found only by attempting — credentials the backend rejects, a backend that
+ * does not answer — is not a refusal. It arrives as a ManagementAck, with the backend
+ * health it left (FAILING, e.g. with AUTH_FAILED, UNREACHABLE or BACKEND_ERROR) already
+ * pushed: after the ack, the app reads ConnectorDescriptor.backend_health for the outcome,
+ * and a FAILING health there means the reconnect did not help. The app handles any reason
+ * there, one its schema does not know included. No push precedes the ack when the attempt
+ * left health as it was; the descriptor the app holds is then still the outcome.
+ *
+ * A refusal is a GatewayError whose metadata "reason" says which, as CommandError.metadata
+ * describes, and whose "detail" is a sentence the app may show. The app branches on
+ * "reason" for this operation; the code is only the fallback for a reason it does not know,
+ * since GatewayErrorCode is too coarse to say what to do here. The role refusal above is
+ * the code NOT_ENTITLED alone, with no "reason"; the reasons are for a caller who may ask:
+ *   "UNKNOWN_CONNECTOR"    UNAVAILABLE. The gateway does not track a connector by that id:
+ *                          it never had one, or has stopped tracking it. Not a client bug:
+ *                          the list the app holds may be stale.
+ *   "CONNECTOR_OFFLINE"    UNAVAILABLE. A connector the gateway tracks, whose stream to the
+ *                          gateway is down now, before or while the request was
+ *                          outstanding; that is CONNECTOR_OFFLINE, and a reconnect of its
+ *                          backend cannot help it.
+ *   "NOT_SUPPORTED"        FAILED_PRECONDITION. The connector does not declare
+ *                          ConnectorDescriptor.supports_backend_reinitialize, or declared it
+ *                          and answered that it has nothing to re-initialise. Not a client
+ *                          bug, and not worth retrying as is.
+ *   "ALREADY_IN_PROGRESS"  UNAVAILABLE. A reconnect of this connector is outstanding, from
+ *                          this caller or another. It ends within 60 seconds of being
+ *                          asked, answered or timed out; retry after that. Only the caller
+ *                          who asked is answered, but a change of health it causes reaches
+ *                          every session in ConnectorsAnnounced.
+ *   "TIMED_OUT"            UNAVAILABLE. The connector did not answer within the gateway's
+ *                          deadline. The attempt may still finish, and its outcome still
+ *                          arrives as backend health.
+ *   "REINITIALIZE_FAILED"  The connector could not attempt it at all
+ *                          (connector.v1.REINITIALIZE_OUTCOME_FAILED, or an outcome the
+ *                          gateway's schema does not know, read as FAILED). The code
+ *                          depends on the reason: FAILED_PRECONDITION when it is
+ *                          MISCONFIGURED, which needs a person to correct the connector's
+ *                          configuration before asking again can help; UNAVAILABLE for
+ *                          any other — INTERNAL, UNSPECIFIED, a value the gateway does not
+ *                          know — since a retry may work. Rejected credentials are never
+ *                          this: they are found by attempting, and come back as an ack
+ *                          (see above). metadata "backend_failure" is always set: the
+ *                          common.v1.BackendFailureReason by its enum name, e.g.
+ *                          "BACKEND_FAILURE_REASON_MISCONFIGURED". A reason that is
+ *                          UNSPECIFIED, or a value the gateway's schema does not know, is
+ *                          sent as "BACKEND_FAILURE_REASON_BACKEND_ERROR", as
+ *                          BackendFailureReason has it; an app reading a name its own
+ *                          schema does not know treats it as BACKEND_ERROR too.
+ * The connector's own detail is never in a refusal; GatewayError.message is the gateway's.
+ *
+ * @generated from message kusinta.iot.webrtc.v1.ReconnectConnector
+ */
+export declare type ReconnectConnector = Message<"kusinta.iot.webrtc.v1.ReconnectConnector"> & {
+  /**
+   * As ConnectorDescriptor.connector_id, and the id a CONNECTOR_ERROR problem's subject
+   * names (reporting.v1.ProblemSubject.connector_id).
+   *
+   * @generated from field: kusinta.iot.identity.v1.ConnectorId connector_id = 1;
+   */
+  connectorId?: ConnectorId | undefined;
+};
+
+/**
+ * Describes the message kusinta.iot.webrtc.v1.ReconnectConnector.
+ * Use `create(ReconnectConnectorSchema)` to create a new message.
+ */
+export declare const ReconnectConnectorSchema: GenMessage<ReconnectConnector>;
+
+/**
  * @generated from message kusinta.iot.webrtc.v1.ManagementRequest
  */
 export declare type ManagementRequest = Message<"kusinta.iot.webrtc.v1.ManagementRequest"> & {
@@ -440,6 +1251,160 @@ export declare type ManagementRequest = Message<"kusinta.iot.webrtc.v1.Managemen
      */
     value: ListSpaces;
     case: "listSpaces";
+  } | {
+    /**
+     * @generated from field: kusinta.iot.webrtc.v1.CreateDeviceLink create_device_link = 11;
+     */
+    value: CreateDeviceLink;
+    case: "createDeviceLink";
+  } | {
+    /**
+     * @generated from field: kusinta.iot.webrtc.v1.RemoveDeviceLink remove_device_link = 12;
+     */
+    value: RemoveDeviceLink;
+    case: "removeDeviceLink";
+  } | {
+    /**
+     * @generated from field: kusinta.iot.webrtc.v1.ListDeviceLinks list_device_links = 13;
+     */
+    value: ListDeviceLinks;
+    case: "listDeviceLinks";
+  } | {
+    /**
+     * @generated from field: kusinta.iot.webrtc.v1.UpdateDeviceLink update_device_link = 14;
+     */
+    value: UpdateDeviceLink;
+    case: "updateDeviceLink";
+  } | {
+    /**
+     * @generated from field: kusinta.iot.webrtc.v1.ProvisionDevice provision_device = 15;
+     */
+    value: ProvisionDevice;
+    case: "provisionDevice";
+  } | {
+    /**
+     * @generated from field: kusinta.iot.webrtc.v1.SetRoomTarget set_room_target = 16;
+     */
+    value: SetRoomTarget;
+    case: "setRoomTarget";
+  } | {
+    /**
+     * @generated from field: kusinta.iot.webrtc.v1.ConfigureRoomClimate configure_room_climate = 17;
+     */
+    value: ConfigureRoomClimate;
+    case: "configureRoomClimate";
+  } | {
+    /**
+     * @generated from field: kusinta.iot.webrtc.v1.SetClimateMode set_climate_mode = 18;
+     */
+    value: SetClimateMode;
+    case: "setClimateMode";
+  } | {
+    /**
+     * @generated from field: kusinta.iot.webrtc.v1.ListRoomClimates list_room_climates = 19;
+     */
+    value: ListRoomClimates;
+    case: "listRoomClimates";
+  } | {
+    /**
+     * @generated from field: kusinta.iot.webrtc.v1.GetRoomHistory get_room_history = 20;
+     */
+    value: GetRoomHistory;
+    case: "getRoomHistory";
+  } | {
+    /**
+     * @generated from field: kusinta.iot.webrtc.v1.GetPrivacyDisclosure get_privacy_disclosure = 21;
+     */
+    value: GetPrivacyDisclosure;
+    case: "getPrivacyDisclosure";
+  } | {
+    /**
+     * @generated from field: kusinta.iot.webrtc.v1.GetApartmentClimateSummary get_apartment_climate_summary = 22;
+     */
+    value: GetApartmentClimateSummary;
+    case: "getApartmentClimateSummary";
+  } | {
+    /**
+     * @generated from field: kusinta.iot.webrtc.v1.ReconnectConnector reconnect_connector = 23;
+     */
+    value: ReconnectConnector;
+    case: "reconnectConnector";
+  } | {
+    /**
+     * Invites; see invite.proto.
+     *
+     * @generated from field: kusinta.iot.webrtc.v1.CreateInvite create_invite = 24;
+     */
+    value: CreateInvite;
+    case: "createInvite";
+  } | {
+    /**
+     * @generated from field: kusinta.iot.webrtc.v1.ResendInvite resend_invite = 25;
+     */
+    value: ResendInvite;
+    case: "resendInvite";
+  } | {
+    /**
+     * @generated from field: kusinta.iot.webrtc.v1.RevokeInvite revoke_invite = 26;
+     */
+    value: RevokeInvite;
+    case: "revokeInvite";
+  } | {
+    /**
+     * @generated from field: kusinta.iot.webrtc.v1.MarkInviteEmailSent mark_invite_email_sent = 27;
+     */
+    value: MarkInviteEmailSent;
+    case: "markInviteEmailSent";
+  } | {
+    /**
+     * @generated from field: kusinta.iot.webrtc.v1.ListSpaceInvites list_space_invites = 28;
+     */
+    value: ListSpaceInvites;
+    case: "listSpaceInvites";
+  } | {
+    /**
+     * @generated from field: kusinta.iot.webrtc.v1.ApproveJoinRequest approve_join_request = 29;
+     */
+    value: ApproveJoinRequest;
+    case: "approveJoinRequest";
+  } | {
+    /**
+     * @generated from field: kusinta.iot.webrtc.v1.DenyJoinRequest deny_join_request = 30;
+     */
+    value: DenyJoinRequest;
+    case: "denyJoinRequest";
+  } | {
+    /**
+     * Members; see members.proto.
+     *
+     * @generated from field: kusinta.iot.webrtc.v1.ListGatewayMembers list_gateway_members = 31;
+     */
+    value: ListGatewayMembers;
+    case: "listGatewayMembers";
+  } | {
+    /**
+     * @generated from field: kusinta.iot.webrtc.v1.SetMemberRole set_member_role = 32;
+     */
+    value: SetMemberRole;
+    case: "setMemberRole";
+  } | {
+    /**
+     * @generated from field: kusinta.iot.webrtc.v1.RemoveFromGateway remove_from_gateway = 33;
+     */
+    value: RemoveFromGateway;
+    case: "removeFromGateway";
+  } | {
+    /**
+     * @generated from field: kusinta.iot.webrtc.v1.SetAccessUntil set_access_until = 34;
+     */
+    value: SetAccessUntil;
+    case: "setAccessUntil";
+  } | {
+    /**
+     * @generated from field: kusinta.iot.webrtc.v1.SetOwnerOrganisation set_owner_organisation = 35;
+     */
+    value: SetOwnerOrganisation;
+    case: "setOwnerOrganisation";
   } | { case: undefined; value?: undefined };
 };