@kusinta/iot-schema 0.2.0-beta.22 → 0.2.0-beta.24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kusinta/iot-schema",
-  "version": "0.2.0-beta.22",
+  "version": "0.2.0-beta.24",
   "type": "module",
   "license": "MIT",
   "files": ["src"],

package/src/kusinta/iot/common/v1/types_pb.d.ts

@@ -36,6 +36,37 @@ export declare type ErrorDetail = Message<"kusinta.iot.common.v1.ErrorDetail"> &
  */
 export declare const ErrorDetailSchema: GenMessage<ErrorDetail>;
 
+/**
+ * A connector's backend health, as both legs carry it: connector to gateway inside
+ * connector.v1.BackendHealthReport, and gateway to app on webrtc.v1.ConnectorDescriptor.
+ *
+ * Deliberately state and category only. A connector's free-text detail travels beside this,
+ * on the connector leg alone, and is for the gateway's logs: it may name hosts, addresses or
+ * accounts, and it never reaches the app or the cloud. Carrying only this type on the app
+ * leg is what keeps it there.
+ *
+ * @generated from message kusinta.iot.common.v1.BackendHealth
+ */
+export declare type BackendHealth = Message<"kusinta.iot.common.v1.BackendHealth"> & {
+  /**
+   * @generated from field: kusinta.iot.common.v1.BackendHealthState state = 1;
+   */
+  state: BackendHealthState;
+
+  /**
+   * Why, when state is FAILING. UNSPECIFIED otherwise, and ignored when state is not FAILING.
+   *
+   * @generated from field: kusinta.iot.common.v1.BackendFailureReason reason = 2;
+   */
+  reason: BackendFailureReason;
+};
+
+/**
+ * Describes the message kusinta.iot.common.v1.BackendHealth.
+ * Use `create(BackendHealthSchema)` to create a new message.
+ */
+export declare const BackendHealthSchema: GenMessage<BackendHealth>;
+
 /**
  * @generated from enum kusinta.iot.common.v1.SpaceType
  */
@@ -195,3 +226,113 @@ export enum ConnectorKind {
  */
 export declare const ConnectorKindSchema: GenEnum<ConnectorKind>;
 
+/**
+ * Whether the backend a connector drives is working: the radio central, the network server,
+ * whatever the connector talks to on the far side from the gateway. Distinct from whether
+ * the connector itself is connected — that is the gateway↔connector stream, and a connector
+ * whose stream is down states nothing at all.
+ *
+ * Open, like every proto3 enum: a reader given a value its schema predates holds the number.
+ * Every reader treats anything but FAILING as healthy, so a state added later must be one an
+ * older reader may safely take for OK. A new way of failing is a new BackendFailureReason
+ * under FAILING, never a new state.
+ *
+ * @generated from enum kusinta.iot.common.v1.BackendHealthState
+ */
+export enum BackendHealthState {
+  /**
+   * No statement. Read as OK: a connector that predates backend health, or one whose backend
+   * is still in doubt as it handshakes (see connector.v1.BackendHealthReport), has said
+   * nothing is wrong.
+   *
+   * @generated from enum value: BACKEND_HEALTH_STATE_UNSPECIFIED = 0;
+   */
+  UNSPECIFIED = 0,
+
+  /**
+   * The backend is reachable and answering.
+   *
+   * @generated from enum value: BACKEND_HEALTH_STATE_OK = 1;
+   */
+  OK = 1,
+
+  /**
+   * The backend is failing, and not for a single dropped call: it has been in doubt for 60
+   * seconds within the last 120 (see connector.v1.BackendHealthReport), or the connector's own
+   * retries are used up, or a requested re-initialisation
+   * left it failing (see connector.v1.BackendHealthReport). The connector stays connected to
+   * the gateway.
+   *
+   * @generated from enum value: BACKEND_HEALTH_STATE_FAILING = 2;
+   */
+  FAILING = 2,
+}
+
+/**
+ * Describes the enum kusinta.iot.common.v1.BackendHealthState.
+ */
+export declare const BackendHealthStateSchema: GenEnum<BackendHealthState>;
+
+/**
+ * Why a backend is failing, or why a re-initialisation could not be attempted. Coarse on
+ * purpose: each value answers "what should someone do now?", and the specifics belong in a
+ * connector's log-only detail, never here.
+ *
+ * Shared rather than mirrored, for the reason PairingError gives: the connector produces it
+ * and the gateway passes it through unchanged.
+ *
+ * @generated from enum kusinta.iot.common.v1.BackendFailureReason
+ */
+export enum BackendFailureReason {
+  /**
+   * Not stated, or a value this reader's schema does not know. Read as BACKEND_ERROR.
+   *
+   * @generated from enum value: BACKEND_FAILURE_REASON_UNSPECIFIED = 0;
+   */
+  UNSPECIFIED = 0,
+
+  /**
+   * The backend cannot be reached: no route, connection refused, no answer. Often a power or
+   * network fault at the backend's side; a re-initialisation may help once that is fixed.
+   *
+   * @generated from enum value: BACKEND_FAILURE_REASON_UNREACHABLE = 1;
+   */
+  UNREACHABLE = 1,
+
+  /**
+   * The backend answered and refused the connector's credentials. Retrying the same
+   * credentials will not help; someone must change them.
+   *
+   * @generated from enum value: BACKEND_FAILURE_REASON_AUTH_FAILED = 2;
+   */
+  AUTH_FAILED = 2,
+
+  /**
+   * The backend is reached and authenticated, but answers with errors or not as the connector
+   * expects: a fault on the backend's side, or a version the connector does not understand.
+   *
+   * @generated from enum value: BACKEND_FAILURE_REASON_BACKEND_ERROR = 3;
+   */
+  BACKEND_ERROR = 3,
+
+  /**
+   * The connector lacks what it needs to reach the backend at all: an address, credentials.
+   * Needs an installer, not a retry.
+   *
+   * @generated from enum value: BACKEND_FAILURE_REASON_MISCONFIGURED = 4;
+   */
+  MISCONFIGURED = 4,
+
+  /**
+   * A fault in the connector itself, not in the backend.
+   *
+   * @generated from enum value: BACKEND_FAILURE_REASON_INTERNAL = 5;
+   */
+  INTERNAL = 5,
+}
+
+/**
+ * Describes the enum kusinta.iot.common.v1.BackendFailureReason.
+ */
+export declare const BackendFailureReasonSchema: GenEnum<BackendFailureReason>;
+

package/src/kusinta/iot/common/v1/types_pb.js

@@ -8,7 +8,7 @@ import { enumDesc, fileDesc, messageDesc, tsEnum } from "@bufbuild/protobuf/code
  * Describes the file kusinta/iot/common/v1/types.proto.
  */
 export const file_kusinta_iot_common_v1_types = /*@__PURE__*/
-  fileDesc("CiFrdXNpbnRhL2lvdC9jb21tb24vdjEvdHlwZXMucHJvdG8SFWt1c2ludGEuaW90LmNvbW1vbi52MSKhAQoLRXJyb3JEZXRhaWwSDAoEY29kZRgBIAEoCRIPCgdtZXNzYWdlGAIgASgJEkIKCG1ldGFkYXRhGAMgAygLMjAua3VzaW50YS5pb3QuY29tbW9uLnYxLkVycm9yRGV0YWlsLk1ldGFkYXRhRW50cnkaLwoNTWV0YWRhdGFFbnRyeRILCgNrZXkYASABKAkSDQoFdmFsdWUYAiABKAk6AjgBKqEBCglTcGFjZVR5cGUSGgoWU1BBQ0VfVFlQRV9VTlNQRUNJRklFRBAAEhcKE1NQQUNFX1RZUEVfQlVJTERJTkcQARIUChBTUEFDRV9UWVBFX0ZMT09SEAISGAoUU1BBQ0VfVFlQRV9BUEFSVE1FTlQQAxITCg9TUEFDRV9UWVBFX1JPT00QBBIaChZTUEFDRV9UWVBFX0NPTU1PTl9BUkVBEAUqgwEKE0RldmljZU93bmVyc2hpcFR5cGUSJQohREVWSUNFX09XTkVSU0hJUF9UWVBFX1VOU1BFQ0lGSUVEEAASIQodREVWSUNFX09XTkVSU0hJUF9UWVBFX0NPTVBBTlkQARIiCh5ERVZJQ0VfT1dORVJTSElQX1RZUEVfUkVTSURFTlQQAirhAQoURGV2aWNlTGlmZWN5Y2xlU3RhdGUSJgoiREVWSUNFX0xJRkVDWUNMRV9TVEFURV9VTlNQRUNJRklFRBAAEigKJERFVklDRV9MSUZFQ1lDTEVfU1RBVEVfUEVORElOR19DTEFJTRABEiAKHERFVklDRV9MSUZFQ1lDTEVfU1RBVEVfT1dORUQQAhIrCidERVZJQ0VfTElGRUNZQ0xFX1NUQVRFX1BFTkRJTkdfVFJBTlNGRVIQAxIoCiRERVZJQ0VfTElGRUNZQ0xFX1NUQVRFX0JVSUxESU5HX1BPT0wQBCqAAQoSQ29ubmVjdG9yVHJhbnNwb3J0EiMKH0NPTk5FQ1RPUl9UUkFOU1BPUlRfVU5TUEVDSUZJRUQQABIjCh9DT05ORUNUT1JfVFJBTlNQT1JUX1VOSVhfU09DS0VUEAESIAocQ09OTkVDVE9SX1RSQU5TUE9SVF9NVExTX1RDUBACKmwKDUNvbm5lY3RvcktpbmQSHgoaQ09OTkVDVE9SX0tJTkRfVU5TUEVDSUZJRUQQABIfChtDT05ORUNUT1JfS0lORF9IT01FTUFUSUNfSVAQARIaChZDT05ORUNUT1JfS0lORF9MT1JBV0FOEAJCAkgBYgZwcm90bzM");
+  fileDesc("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");
 
 /**
  * Describes the message kusinta.iot.common.v1.ErrorDetail.
@@ -17,6 +17,13 @@ export const file_kusinta_iot_common_v1_types = /*@__PURE__*/
 export const ErrorDetailSchema = /*@__PURE__*/
   messageDesc(file_kusinta_iot_common_v1_types, 0);
 
+/**
+ * Describes the message kusinta.iot.common.v1.BackendHealth.
+ * Use `create(BackendHealthSchema)` to create a new message.
+ */
+export const BackendHealthSchema = /*@__PURE__*/
+  messageDesc(file_kusinta_iot_common_v1_types, 1);
+
 /**
  * Describes the enum kusinta.iot.common.v1.SpaceType.
  */
@@ -86,3 +93,44 @@ export const ConnectorKindSchema = /*@__PURE__*/
 export const ConnectorKind = /*@__PURE__*/
   tsEnum(ConnectorKindSchema);
 
+/**
+ * Describes the enum kusinta.iot.common.v1.BackendHealthState.
+ */
+export const BackendHealthStateSchema = /*@__PURE__*/
+  enumDesc(file_kusinta_iot_common_v1_types, 5);
+
+/**
+ * Whether the backend a connector drives is working: the radio central, the network server,
+ * whatever the connector talks to on the far side from the gateway. Distinct from whether
+ * the connector itself is connected — that is the gateway↔connector stream, and a connector
+ * whose stream is down states nothing at all.
+ *
+ * Open, like every proto3 enum: a reader given a value its schema predates holds the number.
+ * Every reader treats anything but FAILING as healthy, so a state added later must be one an
+ * older reader may safely take for OK. A new way of failing is a new BackendFailureReason
+ * under FAILING, never a new state.
+ *
+ * @generated from enum kusinta.iot.common.v1.BackendHealthState
+ */
+export const BackendHealthState = /*@__PURE__*/
+  tsEnum(BackendHealthStateSchema);
+
+/**
+ * Describes the enum kusinta.iot.common.v1.BackendFailureReason.
+ */
+export const BackendFailureReasonSchema = /*@__PURE__*/
+  enumDesc(file_kusinta_iot_common_v1_types, 6);
+
+/**
+ * Why a backend is failing, or why a re-initialisation could not be attempted. Coarse on
+ * purpose: each value answers "what should someone do now?", and the specifics belong in a
+ * connector's log-only detail, never here.
+ *
+ * Shared rather than mirrored, for the reason PairingError gives: the connector produces it
+ * and the gateway passes it through unchanged.
+ *
+ * @generated from enum kusinta.iot.common.v1.BackendFailureReason
+ */
+export const BackendFailureReason = /*@__PURE__*/
+  tsEnum(BackendFailureReasonSchema);
+

package/src/kusinta/iot/connector/v1/connector_pb.d.ts

@@ -2,10 +2,10 @@
 // @generated from file kusinta/iot/connector/v1/connector.proto (package kusinta.iot.connector.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 { ConnectorId, DeviceId, GatewayId } from "../../identity/v1/identity_pb.js";
-import type { ConnectorKind, ConnectorTransport } from "../../common/v1/types_pb.js";
+import type { BackendFailureReason, BackendHealth, ConnectorKind, ConnectorTransport } from "../../common/v1/types_pb.js";
 import type { Device } from "../../device/v1/device_pb.js";
 import type { DeviceLink, LinkFunction, LinkState } from "../../link/v1/link_pb.js";
 import type { Timestamp } from "@bufbuild/protobuf/wkt";
@@ -106,6 +106,17 @@ export declare type ConnectorInfo = Message<"kusinta.iot.connector.v1.ConnectorI
    * @generated from field: string description = 11;
    */
   description: string;
+
+  /**
+   * The connector answers ReinitializeBackend: it can drop and re-establish its connection
+   * to its backend on request. The gateway sends ReinitializeBackend only to a connector
+   * that declares this, and refuses a reconnect for any other without asking it — a
+   * connector whose schema predates the message would ignore it, and the gateway would wait
+   * out its deadline for nothing.
+   *
+   * @generated from field: bool supports_backend_reinitialize = 12;
+   */
+  supportsBackendReinitialize: boolean;
 };
 
 /**
@@ -143,6 +154,34 @@ export declare type ConnectorHandshake = Message<"kusinta.iot.connector.v1.Conne
    * @generated from field: repeated kusinta.iot.link.v1.DeviceLink known_links = 3;
    */
   knownLinks: DeviceLink[];
+
+  /**
+   * The backend's health as the connector handshakes, so the gateway starts every session
+   * from the current state rather than from whatever it held before the stream dropped.
+   * From then on, changes arrive as BackendHealthReport on the session.
+   *
+   * Unset states nothing, and the gateway reads it as OK: a connector that predates backend
+   * health never sends it, and is never taken to be failing. A connector whose backend has
+   * not answered a call since it connected to the gateway — its backend is still in
+   * doubt — leaves it unset, or states FAILING only where BackendHealthReport's rules for
+   * FAILING already hold; never OK.
+   *
+   * After connecting to a gateway that sets HandshakeAck.supports_backend_health, a
+   * connector that reports backend health follows the rules on BackendHealthReport: its
+   * backend is in doubt from connecting to the gateway until it first answers, so the
+   * connector states OK (once it has answered) or FAILING within 60 seconds, here or in a
+   * BackendHealthReport, reports none of its devices as unreachable while its backend is in
+   * doubt, and re-reports them once it is not, as BackendHealthReport says. Toward a gateway
+   * that does not set it, none of those rules applies: the connector reports its devices as
+   * it did before backend health existed.
+   *
+   * Safe to set whatever the gateway: the handshake goes before the connector knows which
+   * gateway it reached, and a gateway that predates backend health skips the field as
+   * unknown. Everything after the handshake waits for HandshakeAck.supports_backend_health.
+   *
+   * @generated from field: kusinta.iot.connector.v1.BackendHealthReport backend_health = 4;
+   */
+  backendHealth?: BackendHealthReport | undefined;
 };
 
 /**
@@ -151,6 +190,162 @@ export declare type ConnectorHandshake = Message<"kusinta.iot.connector.v1.Conne
  */
 export declare const ConnectorHandshakeSchema: GenMessage<ConnectorHandshake>;
 
+/**
+ * The health of the backend the connector drives, connector to gateway: whether the radio
+ * central or network server behind it is working. See common.v1.BackendHealth.
+ *
+ * Sent on the session only to a gateway that sets HandshakeAck.supports_backend_health; the
+ * handshake's ConnectorHandshake.backend_health is set whatever the gateway, since the ack is
+ * not yet known. To a gateway that does not set it — one that predates backend health — the
+ * connector sends neither this on the session nor
+ * ReinitializeBackendResult, and keeps working as it did before: its backend failing is
+ * then only in its own logs.
+ *
+ * Sent in the handshake (ConnectorHandshake.backend_health), then whenever state or reason
+ * changes, and once after every requested re-initialisation (ReinitializeBackend) it
+ * attempts, changed or not, before the
+ * result that answers it. Not sent for a change of detail alone. Each report replaces the
+ * last.
+ *
+ * The connector's backend is in doubt from when the connector connects to the gateway (each
+ * session, whether or not the backend kept answering meanwhile), from any failed call
+ * to the backend, and from a re-initialisation the connector attempts, until the backend
+ * answers a call again; OK
+ * is stated only once it has. While it is in doubt the
+ * connector reports none of its devices as unreachable, by whatever its technology uses to
+ * say so: a device it cannot reach then may be the backend's fault. The gateway applies no
+ * debounce of its own, so the connector never reports FAILING for a single failed call: it
+ * reports FAILING once its backend has been in doubt for 60 seconds in all within the last
+ * 120 — so a backend that hangs, or answers only now and then, reaches it, and brief failures
+ * between answers do not — or sooner when its own
+ * retries are used up, with the reason of its latest failed call, or UNREACHABLE when none
+ * has failed yet. After a ReinitializeBackend it reports the attempt's true outcome at once,
+ * FAILING included, or OK, before the result: the request is the retry a person asked for.
+ * A backend outage the connector rides out within 60 seconds opens no problem, and what the
+ * backend then says of its devices is reported as it is.
+ *
+ * When its backend stops being in doubt, whatever started it, the connector reports, within
+ * 30 seconds, the current reachability of every device it knows, reachable ones included. If
+ * doubt comes back before it is done, it still reports the devices it knows to be reachable,
+ * and the rest once the doubt ends. The gateway closes
+ * a device's offline problem as recovered only on a report that the device is reachable —
+ * this one or any later one — never on silence; it closes for other reasons as reporting.v1
+ * says.
+ *
+ * The gateway raises reporting.v1.PROBLEM_KIND_CONNECTOR_ERROR for this connector while its
+ * stream is up and the latest report is FAILING, and clears it when one is anything else; a
+ * stream that drops closes it too, and the next handshake decides afresh (see reporting.v1).
+ * A connector that never sends one is OK throughout. CONNECTOR_OFFLINE is the other problem
+ * and is not this one: that is the stream to the gateway down, this is the stream up and
+ * the backend failing.
+ *
+ * @generated from message kusinta.iot.connector.v1.BackendHealthReport
+ */
+export declare type BackendHealthReport = Message<"kusinta.iot.connector.v1.BackendHealthReport"> & {
+  /**
+   * @generated from field: kusinta.iot.common.v1.BackendHealth health = 1;
+   */
+  health?: BackendHealth | undefined;
+
+  /**
+   * What went wrong, in the connector's words — an error message, the host it could not
+   * reach. For the gateway's logs only. The gateway never forwards it: not to the app, not
+   * to the cloud, not into a problem report. Empty when there is nothing to add.
+   *
+   * @generated from field: string detail = 2;
+   */
+  detail: string;
+};
+
+/**
+ * Describes the message kusinta.iot.connector.v1.BackendHealthReport.
+ * Use `create(BackendHealthReportSchema)` to create a new message.
+ */
+export declare const BackendHealthReportSchema: GenMessage<BackendHealthReport>;
+
+/**
+ * Asks the connector to re-initialise its backend connection, gateway to connector: drop
+ * the connection to its radio central or network server and establish it again, as it would
+ * at startup. Sent only to a connector that declares
+ * ConnectorInfo.supports_backend_reinitialize.
+ *
+ * Idempotent. Re-initialising a healthy backend is harmless, and asking twice is the same as
+ * asking once: a ReinitializeBackend that arrives while one is running starts nothing new,
+ * and is answered with the running one's outcome when it finishes. The gateway sends at most
+ * one at a time per connector and refuses a second request from above while one is
+ * outstanding; the connector's coalescing covers the case where the gateway gave up waiting
+ * and asked again.
+ *
+ * Sent only by a gateway that sets HandshakeAck.supports_backend_health, so a connector
+ * that receives it may answer. Answered once, by ReinitializeBackendResult with the same
+ * request_id. The connector bounds its attempt so that it answers within 30 seconds of
+ * receiving this; the gateway waits at least 45 and at most 60 seconds before it treats the
+ * request as timed out. A result arriving after the gateway has given up is ignored, but the
+ * health report sent before it still applies.
+ *
+ * @generated from message kusinta.iot.connector.v1.ReinitializeBackend
+ */
+export declare type ReinitializeBackend = Message<"kusinta.iot.connector.v1.ReinitializeBackend"> & {
+  /**
+   * minted by the gateway, echoed in the result
+   *
+   * @generated from field: string request_id = 1;
+   */
+  requestId: string;
+};
+
+/**
+ * Describes the message kusinta.iot.connector.v1.ReinitializeBackend.
+ * Use `create(ReinitializeBackendSchema)` to create a new message.
+ */
+export declare const ReinitializeBackendSchema: GenMessage<ReinitializeBackend>;
+
+/**
+ * What became of a ReinitializeBackend, connector to gateway.
+ *
+ * DONE means the attempt was made and has finished — not that it succeeded. Whether the
+ * backend works now is stated by the BackendHealthReport the connector sends after every
+ * attempt, before this result, so a gateway reading DONE already holds the outcome. Keeping
+ * the two apart means there is one place that says whether a backend is healthy, and a
+ * result cannot contradict it.
+ *
+ * @generated from message kusinta.iot.connector.v1.ReinitializeBackendResult
+ */
+export declare type ReinitializeBackendResult = Message<"kusinta.iot.connector.v1.ReinitializeBackendResult"> & {
+  /**
+   * @generated from field: string request_id = 1;
+   */
+  requestId: string;
+
+  /**
+   * @generated from field: kusinta.iot.connector.v1.ReinitializeOutcome outcome = 2;
+   */
+  outcome: ReinitializeOutcome;
+
+  /**
+   * Why it could not be attempted, when outcome is FAILED: MISCONFIGURED or INTERNAL.
+   * UNSPECIFIED otherwise. Never a failure found by attempting — rejected credentials, a
+   * backend that does not answer: the attempt was made, so the outcome is DONE and the
+   * health report before it says FAILING with AUTH_FAILED, UNREACHABLE or the like.
+   *
+   * @generated from field: kusinta.iot.common.v1.BackendFailureReason reason = 3;
+   */
+  reason: BackendFailureReason;
+
+  /**
+   * For the gateway's logs only, as BackendHealthReport.detail; never forwarded.
+   *
+   * @generated from field: string detail = 4;
+   */
+  detail: string;
+};
+
+/**
+ * Describes the message kusinta.iot.connector.v1.ReinitializeBackendResult.
+ * Use `create(ReinitializeBackendResultSchema)` to create a new message.
+ */
+export declare const ReinitializeBackendResultSchema: GenMessage<ReinitializeBackendResult>;
+
 /**
  * Asks the connector to make a link, gateway to connector.
  *
@@ -326,6 +521,16 @@ export declare type HandshakeAck = Message<"kusinta.iot.connector.v1.HandshakeAc
    * @generated from field: kusinta.iot.identity.v1.GatewayId gateway_id = 3;
    */
   gatewayId?: GatewayId | undefined;
+
+  /**
+   * The gateway understands BackendHealthReport and ReinitializeBackendResult. A connector
+   * sends either on the session only when this is set. Unset — a gateway that predates
+   * backend health — the connector sends neither and works as before; such a gateway never
+   * sends ReinitializeBackend.
+   *
+   * @generated from field: bool supports_backend_health = 4;
+   */
+  supportsBackendHealth: boolean;
 };
 
 /**
@@ -759,6 +964,20 @@ export declare type SessionRequest = Message<"kusinta.iot.connector.v1.SessionRe
      */
     value: LinksReported;
     case: "linksReported";
+  } | {
+    /**
+     * The backend's health; see BackendHealthReport.
+     *
+     * @generated from field: kusinta.iot.connector.v1.BackendHealthReport backend_health = 14;
+     */
+    value: BackendHealthReport;
+    case: "backendHealth";
+  } | {
+    /**
+     * @generated from field: kusinta.iot.connector.v1.ReinitializeBackendResult reinitialize_backend_result = 15;
+     */
+    value: ReinitializeBackendResult;
+    case: "reinitializeBackendResult";
   } | { case: undefined; value?: undefined };
 };
 
@@ -854,6 +1073,14 @@ export declare type SessionResponse = Message<"kusinta.iot.connector.v1.SessionR
      */
     value: ListLinks;
     case: "listLinks";
+  } | {
+    /**
+     * See ReinitializeBackend.
+     *
+     * @generated from field: kusinta.iot.connector.v1.ReinitializeBackend reinitialize_backend = 14;
+     */
+    value: ReinitializeBackend;
+    case: "reinitializeBackend";
   } | { case: undefined; value?: undefined };
 };
 
@@ -863,3 +1090,44 @@ export declare type SessionResponse = Message<"kusinta.iot.connector.v1.SessionR
  */
 export declare const SessionResponseSchema: GenMessage<SessionResponse>;
 
+/**
+ * @generated from enum kusinta.iot.connector.v1.ReinitializeOutcome
+ */
+export enum ReinitializeOutcome {
+  /**
+   * Not stated, or a value this gateway's schema does not know. Read as FAILED.
+   *
+   * @generated from enum value: REINITIALIZE_OUTCOME_UNSPECIFIED = 0;
+   */
+  UNSPECIFIED = 0,
+
+  /**
+   * The connection was dropped and an attempt to establish it again has finished. Its
+   * outcome is the BackendHealthReport sent just before.
+   *
+   * @generated from enum value: REINITIALIZE_OUTCOME_DONE = 1;
+   */
+  DONE = 1,
+
+  /**
+   * The connector could not attempt it at all — no configuration to reconnect with, a fault
+   * of its own. Health is unchanged and no report precedes this.
+   *
+   * @generated from enum value: REINITIALIZE_OUTCOME_FAILED = 2;
+   */
+  FAILED = 2,
+
+  /**
+   * The connector has no backend connection it can re-initialise. A connector that answers
+   * this should not declare supports_backend_reinitialize, but the gateway must handle it.
+   *
+   * @generated from enum value: REINITIALIZE_OUTCOME_NOT_SUPPORTED = 3;
+   */
+  NOT_SUPPORTED = 3,
+}
+
+/**
+ * Describes the enum kusinta.iot.connector.v1.ReinitializeOutcome.
+ */
+export declare const ReinitializeOutcomeSchema: GenEnum<ReinitializeOutcome>;
+