@kusinta/iot-schema 0.1.0-beta.9 → 0.2.0-beta.10

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

@@ -2,13 +2,20 @@
 // @generated from file kusinta/iot/webrtc/v1/envelope.proto (package kusinta.iot.webrtc.v1, syntax proto3)
 /* eslint-disable */
 
-import type { GenFile, GenMessage } from "@bufbuild/protobuf/codegenv2";
+import type { GenEnum, GenFile, GenMessage } from "@bufbuild/protobuf/codegenv2";
 import type { Message } from "@bufbuild/protobuf";
-import type { DeviceId } from "../../identity/v1/identity_pb.js";
+import type { ConnectorId, DeviceId, SpaceId } from "../../identity/v1/identity_pb.js";
+import type { AttributeRef } from "../../access/v1/acl_pb.js";
+import type { Space } from "../../space/v1/space_pb.js";
+import type { ManagementAck, ManagementRequest, SpaceTree } from "./management_pb.js";
+import type { DeviceLink, DeviceLinkList } from "../../link/v1/link_pb.js";
+import type { PairingErrorDetail, PairingWindow } from "../../common/v1/pairing_pb.js";
+import type { DeviceOwnershipType } from "../../common/v1/types_pb.js";
 import type { Timestamp } from "@bufbuild/protobuf/wkt";
-import type { DevicePropertyEvent, DeviceStateSnapshot } from "./device_state_pb.js";
+import type { DeviceAdded, DeviceRemoved, DeviceStateSnapshot, PropertyReport } from "./device_state_pb.js";
 import type { LivePermissionUpdate } from "./permission_push_pb.js";
-import type { CommandResult, DeviceCommand } from "./command_pb.js";
+import type { AttributeWriteRequest, CommandResult, DeviceCommand } from "./command_pb.js";
+import type { DeviceEventBatch } from "../../device/v1/device_event_pb.js";
 
 /**
  * Describes the file kusinta/iot/webrtc/v1/envelope.proto.
@@ -56,19 +63,29 @@ export declare type HandshakeRejected = Message<"kusinta.iot.webrtc.v1.Handshake
 export declare const HandshakeRejectedSchema: GenMessage<HandshakeRejected>;
 
 /**
- * AppHandshake must be the first message sent by the Flutter app on the data channel.
- * The gateway validates the JWT locally using the mykusinta-api-server public key,
+ * AppHandshake must be the first message sent by the app on the data channel.
+ * The gateway validates the JWT locally using the api-server's public key,
  * checks that gateway_id in the JWT matches this gateway, then extracts the role.
  *
  * @generated from message kusinta.iot.webrtc.v1.AppHandshake
  */
 export declare type AppHandshake = Message<"kusinta.iot.webrtc.v1.AppHandshake"> & {
   /**
+   * Signed compact JWS. Its payload claims are documented by AppTokenClaims
+   * in app_token.proto — the shared contract between the api-server (issuer)
+   * and the gateway (validator).
+   *
    * @generated from field: string jwt = 1;
    */
   jwt: string;
 
   /**
+   * Initial interest set — an optimisation that saves one round trip, equivalent to
+   * sending SubscribeDevices immediately after the handshake. Interest only: naming
+   * an id here does not entitle the app to it, and ids the user may not see are
+   * refused in the SubscriptionAck that follows. Not the only mechanism — the set is
+   * revisable mid-session via AppMessage.subscribe / .unsubscribe.
+   *
    * @generated from field: repeated kusinta.iot.identity.v1.DeviceId subscribe_device_ids = 2;
    */
   subscribeDeviceIds: DeviceId[];
@@ -81,23 +98,129 @@ export declare type AppHandshake = Message<"kusinta.iot.webrtc.v1.AppHandshake">
 export declare const AppHandshakeSchema: GenMessage<AppHandshake>;
 
 /**
- * @generated from message kusinta.iot.webrtc.v1.PropertyReadRequest
+ * Adds device_ids to what the app wants streamed. Interest, never entitlement:
+ * the gateway intersects the request with what the user is permitted to see and
+ * reports what it declined in SubscriptionAck.refused. Additive — ids already in
+ * the set are a no-op, so a retry after a dropped ack is safe.
+ *
+ * @generated from message kusinta.iot.webrtc.v1.SubscribeDevices
  */
-export declare type PropertyReadRequest = Message<"kusinta.iot.webrtc.v1.PropertyReadRequest"> & {
+export declare type SubscribeDevices = Message<"kusinta.iot.webrtc.v1.SubscribeDevices"> & {
+  /**
+   * @generated from field: repeated kusinta.iot.identity.v1.DeviceId device_ids = 1;
+   */
+  deviceIds: DeviceId[];
+};
+
+/**
+ * Describes the message kusinta.iot.webrtc.v1.SubscribeDevices.
+ * Use `create(SubscribeDevicesSchema)` to create a new message.
+ */
+export declare const SubscribeDevicesSchema: GenMessage<SubscribeDevices>;
+
+/**
+ * Removes device_ids from what the app wants streamed. Removing an id the app is
+ * not subscribed to is a no-op, not an error.
+ *
+ * @generated from message kusinta.iot.webrtc.v1.UnsubscribeDevices
+ */
+export declare type UnsubscribeDevices = Message<"kusinta.iot.webrtc.v1.UnsubscribeDevices"> & {
+  /**
+   * @generated from field: repeated kusinta.iot.identity.v1.DeviceId device_ids = 1;
+   */
+  deviceIds: DeviceId[];
+};
+
+/**
+ * Describes the message kusinta.iot.webrtc.v1.UnsubscribeDevices.
+ * Use `create(UnsubscribeDevicesSchema)` to create a new message.
+ */
+export declare const UnsubscribeDevicesSchema: GenMessage<UnsubscribeDevices>;
+
+/**
+ * A device the gateway declined to add to the interest set. Ids the gateway does
+ * not know are refused as NOT_ENTITLED rather than a distinct not-found code, so
+ * the ack cannot be used to enumerate devices the user may not see.
+ *
+ * @generated from message kusinta.iot.webrtc.v1.RefusedSubscription
+ */
+export declare type RefusedSubscription = Message<"kusinta.iot.webrtc.v1.RefusedSubscription"> & {
   /**
    * @generated from field: kusinta.iot.identity.v1.DeviceId device_id = 1;
    */
   deviceId?: DeviceId | undefined;
 
   /**
-   * @generated from field: string attribute_name = 2;
+   * @generated from field: kusinta.iot.webrtc.v1.GatewayErrorCode code = 2;
    */
-  attributeName: string;
+  code: GatewayErrorCode;
 
   /**
-   * @generated from field: string cluster_id_hex = 3;
+   * human-readable, for logs
+   *
+   * @generated from field: string message = 3;
    */
-  clusterIdHex: string;
+  message: string;
+};
+
+/**
+ * Describes the message kusinta.iot.webrtc.v1.RefusedSubscription.
+ * Use `create(RefusedSubscriptionSchema)` to create a new message.
+ */
+export declare const RefusedSubscriptionSchema: GenMessage<RefusedSubscription>;
+
+/**
+ * Answer to SubscribeDevices / UnsubscribeDevices, gateway → app.
+ * `subscribed` is the effective set after the change, not a delta: an app that
+ * missed an ack or raced two requests re-syncs from it without reconnecting.
+ *
+ * @generated from message kusinta.iot.webrtc.v1.SubscriptionAck
+ */
+export declare type SubscriptionAck = Message<"kusinta.iot.webrtc.v1.SubscriptionAck"> & {
+  /**
+   * AppMessage.message_id of the request
+   *
+   * @generated from field: string in_reply_to = 1;
+   */
+  inReplyTo: string;
+
+  /**
+   * @generated from field: repeated kusinta.iot.identity.v1.DeviceId subscribed = 2;
+   */
+  subscribed: DeviceId[];
+
+  /**
+   * @generated from field: repeated kusinta.iot.webrtc.v1.RefusedSubscription refused = 3;
+   */
+  refused: RefusedSubscription[];
+};
+
+/**
+ * Describes the message kusinta.iot.webrtc.v1.SubscriptionAck.
+ * Use `create(SubscriptionAckSchema)` to create a new message.
+ */
+export declare const SubscriptionAckSchema: GenMessage<SubscriptionAck>;
+
+/**
+ * Reads one attribute of one endpoint, on demand. The carrier for
+ * PERMISSION_ACTION_READ.
+ *
+ * Addressed by AttributeRef, the same type a write, a grant and a constraint use — so a
+ * read, the write that changes the value, and the permission covering both name the
+ * attribute identically.
+ *
+ * @generated from message kusinta.iot.webrtc.v1.PropertyReadRequest
+ */
+export declare type PropertyReadRequest = Message<"kusinta.iot.webrtc.v1.PropertyReadRequest"> & {
+  /**
+   * @generated from field: kusinta.iot.identity.v1.DeviceId device_id = 1;
+   */
+  deviceId?: DeviceId | undefined;
+
+  /**
+   * @generated from field: kusinta.iot.access.v1.AttributeRef target = 7;
+   */
+  target?: AttributeRef | undefined;
 };
 
 /**
@@ -107,8 +230,311 @@ export declare type PropertyReadRequest = Message<"kusinta.iot.webrtc.v1.Propert
 export declare const PropertyReadRequestSchema: GenMessage<PropertyReadRequest>;
 
 /**
- * GatewayMessage: gateway → Flutter app
+ * Session-level error, gateway → app. Mirrors connector.v1.GatewayError
+ * on the connector leg; kept separate because the two legs have different
+ * authorization semantics and this one has a closed code vocabulary.
+ *
+ * @generated from message kusinta.iot.webrtc.v1.GatewayError
+ */
+export declare type GatewayError = Message<"kusinta.iot.webrtc.v1.GatewayError"> & {
+  /**
+   * @generated from field: kusinta.iot.webrtc.v1.GatewayErrorCode code = 1;
+   */
+  code: GatewayErrorCode;
+
+  /**
+   * human-readable, for logs — never rendered to a user
+   *
+   * @generated from field: string message = 2;
+   */
+  message: string;
+
+  /**
+   * structured detail, e.g. {"device_id": "therm-1"}
+   *
+   * @generated from field: map<string, string> metadata = 3;
+   */
+  metadata: { [key: string]: string };
+};
+
+/**
+ * Describes the message kusinta.iot.webrtc.v1.GatewayError.
+ * Use `create(GatewayErrorSchema)` to create a new message.
+ */
+export declare const GatewayErrorSchema: GenMessage<GatewayError>;
+
+/**
+ * Answer to a ManagementRequest, gateway → app. Lives here rather than beside the
+ * requests in management.proto because it carries GatewayError, which is declared
+ * in this file; the other direction would be an import cycle.
  *
+ * Exactly one result arrives per request, correlated by in_reply_to. A refusal is
+ * an ordinary result, not a session-level error: a filing operation the caller may
+ * not perform says so and the session continues. Targets the caller cannot reach
+ * are refused as NOT_ENTITLED whether or not they exist, so no result here reveals
+ * which spaces or devices are out there.
+ *
+ * @generated from message kusinta.iot.webrtc.v1.ManagementResult
+ */
+export declare type ManagementResult = Message<"kusinta.iot.webrtc.v1.ManagementResult"> & {
+  /**
+   * AppMessage.message_id of the request
+   *
+   * @generated from field: string in_reply_to = 1;
+   */
+  inReplyTo: string;
+
+  /**
+   * @generated from oneof kusinta.iot.webrtc.v1.ManagementResult.result
+   */
+  result: {
+    /**
+     * refused, or the request was malformed
+     *
+     * @generated from field: kusinta.iot.webrtc.v1.GatewayError error = 2;
+     */
+    value: GatewayError;
+    case: "error";
+  } | {
+    /**
+     * create_space, update_space
+     *
+     * @generated from field: kusinta.iot.space.v1.Space space = 3;
+     */
+    value: Space;
+    case: "space";
+  } | {
+    /**
+     * list_spaces
+     *
+     * @generated from field: kusinta.iot.webrtc.v1.SpaceTree space_tree = 4;
+     */
+    value: SpaceTree;
+    case: "spaceTree";
+  } | {
+    /**
+     * everything else
+     *
+     * @generated from field: kusinta.iot.webrtc.v1.ManagementAck ack = 5;
+     */
+    value: ManagementAck;
+    case: "ack";
+  } | {
+    /**
+     * list_device_links
+     *
+     * @generated from field: kusinta.iot.link.v1.DeviceLinkList links = 6;
+     */
+    value: DeviceLinkList;
+    case: "links";
+  } | { case: undefined; value?: undefined };
+};
+
+/**
+ * Describes the message kusinta.iot.webrtc.v1.ManagementResult.
+ * Use `create(ManagementResultSchema)` to create a new message.
+ */
+export declare const ManagementResultSchema: GenMessage<ManagementResult>;
+
+/**
+ * Asks the gateway to put a connector into pairing mode, so a device joined during the
+ * window becomes the caller's rather than belonging to nobody.
+ *
+ * A payload case of its own rather than a ManagementRequest. Those are gated on a target —
+ * a space, a device — and that is the justification for keeping them behind one wrapper.
+ * This one names no target: connector_id is optional, and unset means every connector, so
+ * it is authorized against the caller's role and nothing else.
+ *
+ * Answered twice, and the two answers say different things at different times.
+ * PairingStarted reports whether the window opened; PairingFinished reports what came of
+ * it, seconds or minutes later, once someone has pressed a button on hardware that may be
+ * asleep or out of range.
+ *
+ * @generated from message kusinta.iot.webrtc.v1.StartPairing
+ */
+export declare type StartPairing = Message<"kusinta.iot.webrtc.v1.StartPairing"> & {
+  /**
+   * Which connector to open. Unset means every connector the gateway holds, which is the
+   * sensible default: a device picks its hub by radio range, and asking a user to choose is
+   * asking them to guess at something they cannot observe.
+   *
+   * Name one where the answer is not a guess — a device that will be linked to devices on a
+   * particular hub has to join that hub, because links are held by the hub that brokered
+   * them.
+   *
+   * @generated from field: kusinta.iot.identity.v1.ConnectorId connector_id = 1;
+   */
+  connectorId?: ConnectorId | undefined;
+
+  /**
+   * How long, which device, how many. See PairingWindow.
+   *
+   * @generated from field: kusinta.iot.common.v1.PairingWindow window = 2;
+   */
+  window?: PairingWindow | undefined;
+
+  /**
+   * Where to file the device once it arrives.
+   *
+   * Optional, and the two cases differ. A caller pairing a device of their own must name a
+   * space they reach, so it is theirs and placed on arrival rather than sitting unfiled and
+   * invisible to them. A caller commissioning for a building may leave it unset: a building
+   * is commissioned before its spaces are recorded, and an unfiled device is visible to the
+   * administrator, who is the person doing the pairing.
+   *
+   * @generated from field: kusinta.iot.identity.v1.SpaceId initial_space_id = 3;
+   */
+  initialSpaceId?: SpaceId | undefined;
+
+  /**
+   * What the device should become. Unset lets the gateway decide from the caller's role,
+   * which is the reading that scales: someone commissioning fifty devices for a building
+   * should not come to own fifty devices because a field defaulted.
+   *
+   * The gateway refuses an ownership the caller may not confer, and never mints ownership
+   * for a third party — handing a device to someone else is a transfer, a separate operation
+   * with its own authority.
+   *
+   * @generated from field: kusinta.iot.common.v1.DeviceOwnershipType ownership = 4;
+   */
+  ownership: DeviceOwnershipType;
+};
+
+/**
+ * Describes the message kusinta.iot.webrtc.v1.StartPairing.
+ * Use `create(StartPairingSchema)` to create a new message.
+ */
+export declare const StartPairingSchema: GenMessage<StartPairing>;
+
+/**
+ * Whether the pairing window opened, gateway → app. The first of two answers to a
+ * StartPairing.
+ *
+ * @generated from message kusinta.iot.webrtc.v1.PairingStarted
+ */
+export declare type PairingStarted = Message<"kusinta.iot.webrtc.v1.PairingStarted"> & {
+  /**
+   * AppMessage.message_id of the StartPairing
+   *
+   * @generated from field: string in_reply_to = 1;
+   */
+  inReplyTo: string;
+
+  /**
+   * When the window closes. Present when it opened, and this is the value to count down
+   * from — not the duration that was asked for, which both the gateway and the connector
+   * clamp. A countdown run on the request rather than on this one disagrees with the hub.
+   *
+   * @generated from field: google.protobuf.Timestamp expires_at = 2;
+   */
+  expiresAt?: Timestamp | undefined;
+
+  /**
+   * Why it did not open. Present instead of expires_at.
+   *
+   * @generated from field: kusinta.iot.common.v1.PairingErrorDetail error = 3;
+   */
+  error?: PairingErrorDetail | undefined;
+};
+
+/**
+ * Describes the message kusinta.iot.webrtc.v1.PairingStarted.
+ * Use `create(PairingStartedSchema)` to create a new message.
+ */
+export declare const PairingStartedSchema: GenMessage<PairingStarted>;
+
+/**
+ * What the pairing window produced, gateway → app. The second and last answer, sent once
+ * when the window closes.
+ *
+ * One message per request, not per device: a batch window attributes several, and a client
+ * given one message each has nothing telling it the window is over and no defined moment to
+ * stop waiting. The devices are listed here; each also arrives as an ordinary DeviceAdded
+ * as it appears, so a client may show them as they come and use this to finish.
+ *
+ * An error and a non-empty device list are not exclusive. A batch of five that attributed
+ * three and then expired reports both — three devices and NO_DEVICE_APPEARED — because
+ * "some worked" and "the window ran out" are both true and a user needs to be told both.
+ *
+ * @generated from message kusinta.iot.webrtc.v1.PairingFinished
+ */
+export declare type PairingFinished = Message<"kusinta.iot.webrtc.v1.PairingFinished"> & {
+  /**
+   * AppMessage.message_id of the StartPairing
+   *
+   * @generated from field: string in_reply_to = 1;
+   */
+  inReplyTo: string;
+
+  /**
+   * @generated from field: repeated kusinta.iot.identity.v1.DeviceId device_ids = 2;
+   */
+  deviceIds: DeviceId[];
+
+  /**
+   * Why the window produced fewer devices than asked for, absent when it produced them all.
+   * Note this is not always a failure of the request: a window that simply expired unused
+   * ends here too, and is the ordinary result of a user changing their mind.
+   *
+   * @generated from field: kusinta.iot.common.v1.PairingErrorDetail error = 3;
+   */
+  error?: PairingErrorDetail | undefined;
+};
+
+/**
+ * Describes the message kusinta.iot.webrtc.v1.PairingFinished.
+ * Use `create(PairingFinishedSchema)` to create a new message.
+ */
+export declare const PairingFinishedSchema: GenMessage<PairingFinished>;
+
+/**
+ * GatewayMessage: gateway → app
+ * A link between two devices has changed, gateway to app.
+ *
+ * Sent without being asked for, like device_added, and for the same reason: a link's
+ * state is not settled when it is made. A hub accepting a link is not the two devices
+ * honouring it, and a link that was carrying stops when its sender goes quiet — so the
+ * interesting transitions all happen long after the request that created it was
+ * answered. Without this an app can only learn by listing every link again and
+ * diffing, which means a room that has quietly stopped following its wall thermostat
+ * looks correct until somebody reloads.
+ *
+ * Apply as an upsert keyed on link.link_id, never as an insert: the same link is sent
+ * again whenever its state moves.
+ *
+ * Sent only for links the recipient is entitled to see. An unfiltered one would say
+ * which devices exist and how they are arranged, to somebody entitled to neither.
+ *
+ * @generated from message kusinta.iot.webrtc.v1.LinkChanged
+ */
+export declare type LinkChanged = Message<"kusinta.iot.webrtc.v1.LinkChanged"> & {
+  /**
+   * @generated from field: kusinta.iot.link.v1.DeviceLink link = 1;
+   */
+  link?: DeviceLink | undefined;
+
+  /**
+   * The link is gone, rather than merely not carrying. Distinct from a BROKEN state
+   * because the two need opposite responses: a removal is finished business, while a
+   * link that has stopped carrying is a fault worth showing somebody. Announcing a
+   * deletion as BROKEN would leave every removed link looking like something to go
+   * and repair.
+   *
+   * `link` still carries the whole link when this is set, so the app can name what
+   * went rather than only its id.
+   *
+   * @generated from field: bool removed = 2;
+   */
+  removed: boolean;
+};
+
+/**
+ * Describes the message kusinta.iot.webrtc.v1.LinkChanged.
+ * Use `create(LinkChangedSchema)` to create a new message.
+ */
+export declare const LinkChangedSchema: GenMessage<LinkChanged>;
+
+/**
  * @generated from message kusinta.iot.webrtc.v1.GatewayMessage
  */
 export declare type GatewayMessage = Message<"kusinta.iot.webrtc.v1.GatewayMessage"> & {
@@ -133,10 +559,10 @@ export declare type GatewayMessage = Message<"kusinta.iot.webrtc.v1.GatewayMessa
     case: "stateSnapshot";
   } | {
     /**
-     * @generated from field: kusinta.iot.webrtc.v1.DevicePropertyEvent property_event = 4;
+     * @generated from field: kusinta.iot.webrtc.v1.PropertyReport property_report = 4;
      */
-    value: DevicePropertyEvent;
-    case: "propertyEvent";
+    value: PropertyReport;
+    case: "propertyReport";
   } | {
     /**
      * @generated from field: kusinta.iot.webrtc.v1.LivePermissionUpdate permission_update = 5;
@@ -149,14 +575,6 @@ export declare type GatewayMessage = Message<"kusinta.iot.webrtc.v1.GatewayMessa
      */
     value: CommandResult;
     case: "commandResult";
-  } | {
-    /**
-     * error description string
-     *
-     * @generated from field: string error = 7;
-     */
-    value: string;
-    case: "error";
   } | {
     /**
      * @generated from field: kusinta.iot.webrtc.v1.Pong pong = 8;
@@ -169,6 +587,65 @@ export declare type GatewayMessage = Message<"kusinta.iot.webrtc.v1.GatewayMessa
      */
     value: HandshakeRejected;
     case: "handshakeRejected";
+  } | {
+    /**
+     * @generated from field: kusinta.iot.webrtc.v1.GatewayError error = 10;
+     */
+    value: GatewayError;
+    case: "error";
+  } | {
+    /**
+     * @generated from field: kusinta.iot.webrtc.v1.SubscriptionAck subscription_ack = 11;
+     */
+    value: SubscriptionAck;
+    case: "subscriptionAck";
+  } | {
+    /**
+     * @generated from field: kusinta.iot.webrtc.v1.DeviceAdded device_added = 12;
+     */
+    value: DeviceAdded;
+    case: "deviceAdded";
+  } | {
+    /**
+     * @generated from field: kusinta.iot.webrtc.v1.DeviceRemoved device_removed = 13;
+     */
+    value: DeviceRemoved;
+    case: "deviceRemoved";
+  } | {
+    /**
+     * @generated from field: kusinta.iot.webrtc.v1.ManagementResult management_result = 14;
+     */
+    value: ManagementResult;
+    case: "managementResult";
+  } | {
+    /**
+     * 15 was attribute_write_result. Answers to attribute writes come back as
+     * command_result above instead: a write and an invoke differ in what they do to a
+     * device, not in how the gateway reports having done it, and request_id says which
+     * request is being answered either way.
+     *
+     * @generated from field: kusinta.iot.device.v1.DeviceEventBatch device_events = 16;
+     */
+    value: DeviceEventBatch;
+    case: "deviceEvents";
+  } | {
+    /**
+     * @generated from field: kusinta.iot.webrtc.v1.PairingStarted pairing_started = 17;
+     */
+    value: PairingStarted;
+    case: "pairingStarted";
+  } | {
+    /**
+     * @generated from field: kusinta.iot.webrtc.v1.PairingFinished pairing_finished = 18;
+     */
+    value: PairingFinished;
+    case: "pairingFinished";
+  } | {
+    /**
+     * @generated from field: kusinta.iot.webrtc.v1.LinkChanged link_changed = 19;
+     */
+    value: LinkChanged;
+    case: "linkChanged";
   } | { case: undefined; value?: undefined };
 };
 
@@ -179,7 +656,7 @@ export declare type GatewayMessage = Message<"kusinta.iot.webrtc.v1.GatewayMessa
 export declare const GatewayMessageSchema: GenMessage<GatewayMessage>;
 
 /**
- * AppMessage: Flutter app → gateway
+ * AppMessage: app → gateway
  *
  * @generated from message kusinta.iot.webrtc.v1.AppMessage
  */
@@ -221,6 +698,36 @@ export declare type AppMessage = Message<"kusinta.iot.webrtc.v1.AppMessage"> & {
      */
     value: Ping;
     case: "ping";
+  } | {
+    /**
+     * @generated from field: kusinta.iot.webrtc.v1.SubscribeDevices subscribe = 7;
+     */
+    value: SubscribeDevices;
+    case: "subscribe";
+  } | {
+    /**
+     * @generated from field: kusinta.iot.webrtc.v1.UnsubscribeDevices unsubscribe = 8;
+     */
+    value: UnsubscribeDevices;
+    case: "unsubscribe";
+  } | {
+    /**
+     * @generated from field: kusinta.iot.webrtc.v1.ManagementRequest management = 9;
+     */
+    value: ManagementRequest;
+    case: "management";
+  } | {
+    /**
+     * @generated from field: kusinta.iot.webrtc.v1.AttributeWriteRequest attribute_write = 10;
+     */
+    value: AttributeWriteRequest;
+    case: "attributeWrite";
+  } | {
+    /**
+     * @generated from field: kusinta.iot.webrtc.v1.StartPairing start_pairing = 11;
+     */
+    value: StartPairing;
+    case: "startPairing";
   } | { case: undefined; value?: undefined };
 };
 
@@ -230,3 +737,74 @@ export declare type AppMessage = Message<"kusinta.iot.webrtc.v1.AppMessage"> & {
  */
 export declare const AppMessageSchema: GenMessage<AppMessage>;
 
+/**
+ * Machine-readable classification of a session-level gateway error, so the app
+ * can branch without string-matching a human sentence. Deliberately an enum here,
+ * unlike the free-form code on connector.v1.GatewayError: the app leg is versioned
+ * together with the gateway, and clients need an exhaustive switch.
+ *
+ * @generated from enum kusinta.iot.webrtc.v1.GatewayErrorCode
+ */
+export enum GatewayErrorCode {
+  /**
+   * Sender did not set a code, or sent one this client's schema does not know.
+   *
+   * @generated from enum value: GATEWAY_ERROR_CODE_UNSPECIFIED = 0;
+   */
+  UNSPECIFIED = 0,
+
+  /**
+   * Permanent refusal — the user may not see or act on this. Stop asking, tell the user.
+   *
+   * @generated from enum value: GATEWAY_ERROR_CODE_NOT_ENTITLED = 1;
+   */
+  NOT_ENTITLED = 1,
+
+  /**
+   * The app sent something malformed. A client bug: log it, do not retry.
+   *
+   * @generated from enum value: GATEWAY_ERROR_CODE_INVALID_REQUEST = 2;
+   */
+  INVALID_REQUEST = 2,
+
+  /**
+   * Transient failure. Retrying is reasonable.
+   *
+   * @generated from enum value: GATEWAY_ERROR_CODE_UNAVAILABLE = 3;
+   */
+  UNAVAILABLE = 3,
+
+  /**
+   * Gateway-side fault. Not the app's doing; retry cautiously.
+   *
+   * @generated from enum value: GATEWAY_ERROR_CODE_INTERNAL = 4;
+   */
+  INTERNAL = 4,
+
+  /**
+   * The user already holds the maximum number of concurrent sessions this
+   * gateway will keep, and this attempt is refused. Permanent for this attempt:
+   * the limit does not clear on its own, so retrying is exactly the wrong
+   * response — the user must end another session first. Distinct from
+   * NOT_ENTITLED, which is a statement about what the user may see; this user
+   * may, they are simply already connected enough times.
+   *
+   * The limit itself is gateway configuration and deliberately not modelled
+   * here. GatewayError.message carries the specifics so a client can render
+   * something actionable.
+   *
+   * Rollout note: a client whose schema predates this value decodes it as
+   * UNSPECIFIED, which is retryable by design. Client handling must therefore
+   * ship before or with the gateway that emits it, and the gateway must close
+   * the session itself rather than rely on the client standing down.
+   *
+   * @generated from enum value: GATEWAY_ERROR_CODE_SESSION_LIMIT_REACHED = 5;
+   */
+  SESSION_LIMIT_REACHED = 5,
+}
+
+/**
+ * Describes the enum kusinta.iot.webrtc.v1.GatewayErrorCode.
+ */
+export declare const GatewayErrorCodeSchema: GenEnum<GatewayErrorCode>;
+