@camstack/types 1.2.309 → 1.2.311

package/dist/capabilities/local-network.cap.d.ts

@@ -37,10 +37,10 @@ declare const LocalInterfaceSchema: z.ZodObject<{
     mac: z.ZodString;
     kind: z.ZodEnum<{
         docker: "docker";
+        loopback: "loopback";
         lan: "lan";
         wifi: "wifi";
         vpn: "vpn";
-        loopback: "loopback";
         other: "other";
     }>;
     preferred: z.ZodBoolean;
@@ -56,19 +56,20 @@ declare const ConnectionEndpointSchema: z.ZodObject<{
     label: z.ZodString;
     baseUrl: z.ZodString;
     kind: z.ZodEnum<{
+        custom: "custom";
         public: "public";
-        loopback: "loopback";
         "lan-ipv4": "lan-ipv4";
         "lan-ipv6": "lan-ipv6";
+        loopback: "loopback";
         "app-link": "app-link";
     }>;
     interfaceKind: z.ZodEnum<{
         public: "public";
         docker: "docker";
+        loopback: "loopback";
         lan: "lan";
         wifi: "wifi";
         vpn: "vpn";
-        loopback: "loopback";
         other: "other";
     }>;
     plausible: z.ZodBoolean;
@@ -87,7 +88,7 @@ declare const AdvertisedLocalPortSchema: z.ZodObject<{
 }, z.core.$strip>;
 export type AdvertisedLocalPort = z.infer<typeof AdvertisedLocalPortSchema>;
 /**
- * The address flagged for notification links. `baseUrl: null` = AUTO, which
+ * The address flagged for notification taps (`notificationTaps`). `baseUrl: null` = AUTO, which
  * since D709 is the CamStack app link; `resolved` reports the effective value,
  * so the UI can show it either way.
  */
@@ -108,8 +109,9 @@ declare const ViewerEndpointsSchema: z.ZodObject<{
 }, z.core.$strip>;
 export type ViewerEndpoints = z.infer<typeof ViewerEndpointsSchema>;
 /**
- * One audience's hub address (see `hub-address.ts`): the operator's stored
- * override, the address in use, and where it came from.
+ * DEPRECATED compatibility shape of `getHubAddresses` (D729 amendment, kept
+ * for addons built against it): `cluster` is the `internal` role, `browser`
+ * the `publicEndpoint` role; `override` is the flagged address.
  */
 declare const HubAddressSnapshotSchema: z.ZodObject<{
     override: z.ZodNullable<z.ZodString>;
@@ -142,6 +144,153 @@ declare const HubAddressesSchema: z.ZodObject<{
 }, z.core.$strip>;
 export type HubAddresses = z.infer<typeof HubAddressesSchema>;
 export type HubAddressSnapshot = z.infer<typeof HubAddressSnapshotSchema>;
+/**
+ * What an address is used for (`hub-address.ts`, D734). `appConnections` is
+ * many-valued; `notificationTaps`, `publicEndpoint` and `internal` are carried
+ * by at most one address.
+ */
+export declare const HubAddressRoleSchema: z.ZodEnum<{
+    appConnections: "appConnections";
+    notificationTaps: "notificationTaps";
+    internal: "internal";
+    publicEndpoint: "publicEndpoint";
+}>;
+/**
+ * One row of the Network page's Addresses table: a detected endpoint, an
+ * operator-entered custom address, or the CamStack app link — flagged the
+ * same way. A URL that is both detected and entered is ONE row.
+ */
+declare const HubAddressRowSchema: z.ZodObject<{
+    label: z.ZodString;
+    baseUrl: z.ZodString;
+    kind: z.ZodEnum<{
+        custom: "custom";
+        public: "public";
+        "lan-ipv4": "lan-ipv4";
+        "lan-ipv6": "lan-ipv6";
+        loopback: "loopback";
+        "app-link": "app-link";
+    }>;
+    interfaceKind: z.ZodEnum<{
+        public: "public";
+        docker: "docker";
+        loopback: "loopback";
+        lan: "lan";
+        wifi: "wifi";
+        vpn: "vpn";
+        other: "other";
+    }>;
+    plausible: z.ZodBoolean;
+    plausibleReason: z.ZodString;
+    priority: z.ZodNumber;
+    detected: z.ZodBoolean;
+    custom: z.ZodBoolean;
+    flags: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+        appConnections: "appConnections";
+        notificationTaps: "notificationTaps";
+        internal: "internal";
+        publicEndpoint: "publicEndpoint";
+    }>>>;
+    inUse: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+        appConnections: "appConnections";
+        notificationTaps: "notificationTaps";
+        internal: "internal";
+        publicEndpoint: "publicEndpoint";
+    }>>>;
+    eligible: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+        appConnections: "appConnections";
+        notificationTaps: "notificationTaps";
+        internal: "internal";
+        publicEndpoint: "publicEndpoint";
+    }>>>;
+}, z.core.$strip>;
+export type HubAddressRow = z.infer<typeof HubAddressRowSchema>;
+declare const HubAddressBookSchema: z.ZodObject<{
+    rows: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        baseUrl: z.ZodString;
+        kind: z.ZodEnum<{
+            custom: "custom";
+            public: "public";
+            "lan-ipv4": "lan-ipv4";
+            "lan-ipv6": "lan-ipv6";
+            loopback: "loopback";
+            "app-link": "app-link";
+        }>;
+        interfaceKind: z.ZodEnum<{
+            public: "public";
+            docker: "docker";
+            loopback: "loopback";
+            lan: "lan";
+            wifi: "wifi";
+            vpn: "vpn";
+            other: "other";
+        }>;
+        plausible: z.ZodBoolean;
+        plausibleReason: z.ZodString;
+        priority: z.ZodNumber;
+        detected: z.ZodBoolean;
+        custom: z.ZodBoolean;
+        flags: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+            appConnections: "appConnections";
+            notificationTaps: "notificationTaps";
+            internal: "internal";
+            publicEndpoint: "publicEndpoint";
+        }>>>;
+        inUse: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+            appConnections: "appConnections";
+            notificationTaps: "notificationTaps";
+            internal: "internal";
+            publicEndpoint: "publicEndpoint";
+        }>>>;
+        eligible: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+            appConnections: "appConnections";
+            notificationTaps: "notificationTaps";
+            internal: "internal";
+            publicEndpoint: "publicEndpoint";
+        }>>>;
+    }, z.core.$strip>>>;
+    roles: z.ZodObject<{
+        appConnections: z.ZodObject<{
+            flagged: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+            resolved: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+            source: z.ZodEnum<{
+                none: "none";
+                auto: "auto";
+                flagged: "flagged";
+            }>;
+        }, z.core.$strip>;
+        notificationTaps: z.ZodObject<{
+            flagged: z.ZodNullable<z.ZodString>;
+            resolved: z.ZodNullable<z.ZodString>;
+            source: z.ZodEnum<{
+                none: "none";
+                auto: "auto";
+                flagged: "flagged";
+            }>;
+        }, z.core.$strip>;
+        internal: z.ZodObject<{
+            flagged: z.ZodNullable<z.ZodString>;
+            resolved: z.ZodNullable<z.ZodString>;
+            source: z.ZodEnum<{
+                none: "none";
+                auto: "auto";
+                flagged: "flagged";
+            }>;
+        }, z.core.$strip>;
+        publicEndpoint: z.ZodObject<{
+            flagged: z.ZodNullable<z.ZodString>;
+            resolved: z.ZodNullable<z.ZodString>;
+            source: z.ZodEnum<{
+                none: "none";
+                auto: "auto";
+                flagged: "flagged";
+            }>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    appLinkHub: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type HubAddressBook = z.infer<typeof HubAddressBookSchema>;
 export declare const localNetworkCapability: {
     readonly name: "local-network";
     readonly scope: "system";
@@ -162,10 +311,10 @@ export declare const localNetworkCapability: {
                 mac: z.ZodString;
                 kind: z.ZodEnum<{
                     docker: "docker";
+                    loopback: "loopback";
                     lan: "lan";
                     wifi: "wifi";
                     vpn: "vpn";
-                    loopback: "loopback";
                     other: "other";
                 }>;
                 preferred: z.ZodBoolean;
@@ -197,10 +346,10 @@ export declare const localNetworkCapability: {
             mac: z.ZodString;
             kind: z.ZodEnum<{
                 docker: "docker";
+                loopback: "loopback";
                 lan: "lan";
                 wifi: "wifi";
                 vpn: "vpn";
-                loopback: "loopback";
                 other: "other";
             }>;
             preferred: z.ZodBoolean;
@@ -250,19 +399,20 @@ export declare const localNetworkCapability: {
                 label: z.ZodString;
                 baseUrl: z.ZodString;
                 kind: z.ZodEnum<{
+                    custom: "custom";
                     public: "public";
-                    loopback: "loopback";
                     "lan-ipv4": "lan-ipv4";
                     "lan-ipv6": "lan-ipv6";
+                    loopback: "loopback";
                     "app-link": "app-link";
                 }>;
                 interfaceKind: z.ZodEnum<{
                     public: "public";
                     docker: "docker";
+                    loopback: "loopback";
                     lan: "lan";
                     wifi: "wifi";
                     vpn: "vpn";
-                    loopback: "loopback";
                     other: "other";
                 }>;
                 plausible: z.ZodBoolean;
@@ -280,14 +430,13 @@ export declare const localNetworkCapability: {
             }, z.core.$strip>;
         }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
         /**
-         * The address notification links are flagged with. `baseUrl: null` means
-         * AUTO, which is the CamStack app link (D709): viewer taps go through
-         * `https://camstack.zentik.app/…?hub=<appLinkHub>` and open the app. Any
-         * hub address the palette lists can be flagged instead; then viewer taps,
-         * attachment links and action buttons all use it. Signed media and
-         * buttons never use the app link — with it flagged (or AUTO) they keep
-         * the ranked hub ladder (a configured origin, a connected tunnel, then
-         * the LAN), never loopback.
+         * The `notificationTaps` role (D734): where TAPPING a notification opens.
+         * `baseUrl: null` means AUTO, which is the CamStack app link (D709): taps
+         * go through `https://camstack.zentik.app/…?hub=<appLinkHub>` and open the
+         * app. Any hub address the palette lists can be flagged instead; then a
+         * tap opens that address. Only the tap: action buttons, attachment /
+         * media links and admin links follow the `publicEndpoint` role
+         * (`getAddresses().roles.publicEndpoint`), never this one.
          *
          * Why an explicit marker: the automatic ranking cannot know which of
          * several reachable addresses the RECIPIENT can actually open. A link is
@@ -301,10 +450,9 @@ export declare const localNetworkCapability: {
             appLinkHub: z.ZodNullable<z.ZodString>;
         }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
         /**
-         * Mark which endpoint notification artifacts use. `baseUrl: null` restores
-         * AUTO. The value is stored verbatim (not an index into the candidate
-         * list): interfaces come and go, and an index would silently re-point at a
-         * different address after a reboot.
+         * @deprecated Use `setAddressRole({ role: 'notificationTaps', … })`. It
+         * writes the same `notificationTaps` flag, with the same validation. `baseUrl: null` restores automatic; an
+         * address that is not detected becomes a custom address.
          */
         readonly setNotificationEndpoint: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             baseUrl: z.ZodNullable<z.ZodString>;
@@ -314,19 +462,20 @@ export declare const localNetworkCapability: {
             appLinkHub: z.ZodNullable<z.ZodString>;
         }, z.core.$strip>, "mutation">;
         /**
-         * The endpoints the SDK / viewer races for API access. Empty `baseUrls`
-         * means AUTO: every LAN IPv4 address plus the public tunnel, never IPv6,
-         * never mesh, never loopback. `resolved` is that set (or the operator's
-         * explicit subset) as it stands right now.
+         * The `appConnections` role as shipped apps read it: the flagged addresses
+         * (detected or custom), or empty for AUTO — every LAN IPv4 address plus
+         * the public tunnel, never IPv6, mesh, loopback or a custom address.
+         * `resolved` is the set as it stands right now; the custom ones in it are
+         * also in `getConnectionEndpoints`, which the apps filter by it.
          */
         readonly getViewerEndpoints: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodObject<{
             baseUrls: z.ZodReadonly<z.ZodArray<z.ZodString>>;
             resolved: z.ZodReadonly<z.ZodArray<z.ZodString>>;
         }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
         /**
-         * Replace the viewer race set. Empty `baseUrls` restores AUTO. Stored
-         * verbatim (not indices) so a temporarily-down tunnel is not silently
-         * dropped from the operator's choice.
+         * @deprecated Use `setAddressRole({ role: 'appConnections', … })`. It
+         * replaces the same `appConnections` flags.
+         * Empty `baseUrls` restores automatic.
          */
         readonly setViewerEndpoints: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             baseUrls: z.ZodReadonly<z.ZodArray<z.ZodString>>;
@@ -335,44 +484,398 @@ export declare const localNetworkCapability: {
             resolved: z.ZodReadonly<z.ZodArray<z.ZodString>>;
         }, z.core.$strip>, "mutation">;
         /**
-         * The hub's address for each audience — agents (`cluster`) and sign-in
-         * links (`browser`) — as every consumer must read it: the operator's
-         * override when set, else the automatic pick from this cap's palette,
-         * never loopback. The ONE answer to "at which address is this hub
-         * reached?"; there is no environment variable for it.
+         * The Network page's Addresses table and every role's answer — the ONE
+         * reading of "which address is this hub reached at, for what": detected
+         * endpoints and custom addresses with their role flags, and per role the
+         * flagged address, the one in use and whether it is automatic. Agent
+         * deliveries and LAN devices read `roles.internal`; sign-in, OAuth2 and
+         * the notification centre's buttons / media / admin links read
+         * `roles.publicEndpoint`; nothing ranks the palette itself. `scheme` is
+         * the one the caller shows LAN rows in (as `getConnectionEndpoints`);
+         * `internal` and `publicEndpoint` are always resolved over the HTTPS
+         * palette.
          */
-        readonly getHubAddresses: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodObject<{
-            cluster: z.ZodObject<{
-                override: z.ZodNullable<z.ZodString>;
-                resolved: z.ZodNullable<z.ZodString>;
-                source: z.ZodEnum<{
-                    none: "none";
-                    override: "override";
-                    auto: "auto";
+        readonly getAddresses: import("./capability-definition.js").CapabilityMethodSchema<z.ZodOptional<z.ZodObject<{
+            scheme: z.ZodOptional<z.ZodEnum<{
+                https: "https";
+                http: "http";
+            }>>;
+        }, z.core.$strip>>, z.ZodObject<{
+            rows: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                label: z.ZodString;
+                baseUrl: z.ZodString;
+                kind: z.ZodEnum<{
+                    custom: "custom";
+                    public: "public";
+                    "lan-ipv4": "lan-ipv4";
+                    "lan-ipv6": "lan-ipv6";
+                    loopback: "loopback";
+                    "app-link": "app-link";
                 }>;
-            }, z.core.$strip>;
-            browser: z.ZodObject<{
-                override: z.ZodNullable<z.ZodString>;
-                resolved: z.ZodNullable<z.ZodString>;
-                source: z.ZodEnum<{
-                    none: "none";
-                    override: "override";
-                    auto: "auto";
+                interfaceKind: z.ZodEnum<{
+                    public: "public";
+                    docker: "docker";
+                    loopback: "loopback";
+                    lan: "lan";
+                    wifi: "wifi";
+                    vpn: "vpn";
+                    other: "other";
                 }>;
+                plausible: z.ZodBoolean;
+                plausibleReason: z.ZodString;
+                priority: z.ZodNumber;
+                detected: z.ZodBoolean;
+                custom: z.ZodBoolean;
+                flags: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+                    appConnections: "appConnections";
+                    notificationTaps: "notificationTaps";
+                    internal: "internal";
+                    publicEndpoint: "publicEndpoint";
+                }>>>;
+                inUse: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+                    appConnections: "appConnections";
+                    notificationTaps: "notificationTaps";
+                    internal: "internal";
+                    publicEndpoint: "publicEndpoint";
+                }>>>;
+                eligible: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+                    appConnections: "appConnections";
+                    notificationTaps: "notificationTaps";
+                    internal: "internal";
+                    publicEndpoint: "publicEndpoint";
+                }>>>;
+            }, z.core.$strip>>>;
+            roles: z.ZodObject<{
+                appConnections: z.ZodObject<{
+                    flagged: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+                    resolved: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+                    source: z.ZodEnum<{
+                        none: "none";
+                        auto: "auto";
+                        flagged: "flagged";
+                    }>;
+                }, z.core.$strip>;
+                notificationTaps: z.ZodObject<{
+                    flagged: z.ZodNullable<z.ZodString>;
+                    resolved: z.ZodNullable<z.ZodString>;
+                    source: z.ZodEnum<{
+                        none: "none";
+                        auto: "auto";
+                        flagged: "flagged";
+                    }>;
+                }, z.core.$strip>;
+                internal: z.ZodObject<{
+                    flagged: z.ZodNullable<z.ZodString>;
+                    resolved: z.ZodNullable<z.ZodString>;
+                    source: z.ZodEnum<{
+                        none: "none";
+                        auto: "auto";
+                        flagged: "flagged";
+                    }>;
+                }, z.core.$strip>;
+                publicEndpoint: z.ZodObject<{
+                    flagged: z.ZodNullable<z.ZodString>;
+                    resolved: z.ZodNullable<z.ZodString>;
+                    source: z.ZodEnum<{
+                        none: "none";
+                        auto: "auto";
+                        flagged: "flagged";
+                    }>;
+                }, z.core.$strip>;
             }, z.core.$strip>;
+            appLinkHub: z.ZodNullable<z.ZodString>;
         }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
         /**
-         * Set or clear (`baseUrl: null`) one audience's override. Validated: an
-         * http(s) origin with a host, no credentials, no path, never loopback —
-         * an invalid value is refused with the reason, nothing is stored.
+         * Add a custom address. Validated: an http(s) origin with a host, no
+         * credentials, no path, never loopback — an invalid one is refused with
+         * the reason and nothing is stored. Adding an address that already exists
+         * only updates its label.
          */
-        readonly setHubAddress: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
-            audience: z.ZodEnum<{
-                cluster: "cluster";
-                browser: "browser";
+        readonly addCustomAddress: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            baseUrl: z.ZodString;
+            label: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            rows: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                label: z.ZodString;
+                baseUrl: z.ZodString;
+                kind: z.ZodEnum<{
+                    custom: "custom";
+                    public: "public";
+                    "lan-ipv4": "lan-ipv4";
+                    "lan-ipv6": "lan-ipv6";
+                    loopback: "loopback";
+                    "app-link": "app-link";
+                }>;
+                interfaceKind: z.ZodEnum<{
+                    public: "public";
+                    docker: "docker";
+                    loopback: "loopback";
+                    lan: "lan";
+                    wifi: "wifi";
+                    vpn: "vpn";
+                    other: "other";
+                }>;
+                plausible: z.ZodBoolean;
+                plausibleReason: z.ZodString;
+                priority: z.ZodNumber;
+                detected: z.ZodBoolean;
+                custom: z.ZodBoolean;
+                flags: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+                    appConnections: "appConnections";
+                    notificationTaps: "notificationTaps";
+                    internal: "internal";
+                    publicEndpoint: "publicEndpoint";
+                }>>>;
+                inUse: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+                    appConnections: "appConnections";
+                    notificationTaps: "notificationTaps";
+                    internal: "internal";
+                    publicEndpoint: "publicEndpoint";
+                }>>>;
+                eligible: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+                    appConnections: "appConnections";
+                    notificationTaps: "notificationTaps";
+                    internal: "internal";
+                    publicEndpoint: "publicEndpoint";
+                }>>>;
+            }, z.core.$strip>>>;
+            roles: z.ZodObject<{
+                appConnections: z.ZodObject<{
+                    flagged: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+                    resolved: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+                    source: z.ZodEnum<{
+                        none: "none";
+                        auto: "auto";
+                        flagged: "flagged";
+                    }>;
+                }, z.core.$strip>;
+                notificationTaps: z.ZodObject<{
+                    flagged: z.ZodNullable<z.ZodString>;
+                    resolved: z.ZodNullable<z.ZodString>;
+                    source: z.ZodEnum<{
+                        none: "none";
+                        auto: "auto";
+                        flagged: "flagged";
+                    }>;
+                }, z.core.$strip>;
+                internal: z.ZodObject<{
+                    flagged: z.ZodNullable<z.ZodString>;
+                    resolved: z.ZodNullable<z.ZodString>;
+                    source: z.ZodEnum<{
+                        none: "none";
+                        auto: "auto";
+                        flagged: "flagged";
+                    }>;
+                }, z.core.$strip>;
+                publicEndpoint: z.ZodObject<{
+                    flagged: z.ZodNullable<z.ZodString>;
+                    resolved: z.ZodNullable<z.ZodString>;
+                    source: z.ZodEnum<{
+                        none: "none";
+                        auto: "auto";
+                        flagged: "flagged";
+                    }>;
+                }, z.core.$strip>;
+            }, z.core.$strip>;
+            appLinkHub: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>, "mutation">;
+        /** Remove a custom address. Its role flags go with it (those roles turn automatic). */
+        readonly removeCustomAddress: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            baseUrl: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            rows: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                label: z.ZodString;
+                baseUrl: z.ZodString;
+                kind: z.ZodEnum<{
+                    custom: "custom";
+                    public: "public";
+                    "lan-ipv4": "lan-ipv4";
+                    "lan-ipv6": "lan-ipv6";
+                    loopback: "loopback";
+                    "app-link": "app-link";
+                }>;
+                interfaceKind: z.ZodEnum<{
+                    public: "public";
+                    docker: "docker";
+                    loopback: "loopback";
+                    lan: "lan";
+                    wifi: "wifi";
+                    vpn: "vpn";
+                    other: "other";
+                }>;
+                plausible: z.ZodBoolean;
+                plausibleReason: z.ZodString;
+                priority: z.ZodNumber;
+                detected: z.ZodBoolean;
+                custom: z.ZodBoolean;
+                flags: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+                    appConnections: "appConnections";
+                    notificationTaps: "notificationTaps";
+                    internal: "internal";
+                    publicEndpoint: "publicEndpoint";
+                }>>>;
+                inUse: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+                    appConnections: "appConnections";
+                    notificationTaps: "notificationTaps";
+                    internal: "internal";
+                    publicEndpoint: "publicEndpoint";
+                }>>>;
+                eligible: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+                    appConnections: "appConnections";
+                    notificationTaps: "notificationTaps";
+                    internal: "internal";
+                    publicEndpoint: "publicEndpoint";
+                }>>>;
+            }, z.core.$strip>>>;
+            roles: z.ZodObject<{
+                appConnections: z.ZodObject<{
+                    flagged: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+                    resolved: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+                    source: z.ZodEnum<{
+                        none: "none";
+                        auto: "auto";
+                        flagged: "flagged";
+                    }>;
+                }, z.core.$strip>;
+                notificationTaps: z.ZodObject<{
+                    flagged: z.ZodNullable<z.ZodString>;
+                    resolved: z.ZodNullable<z.ZodString>;
+                    source: z.ZodEnum<{
+                        none: "none";
+                        auto: "auto";
+                        flagged: "flagged";
+                    }>;
+                }, z.core.$strip>;
+                internal: z.ZodObject<{
+                    flagged: z.ZodNullable<z.ZodString>;
+                    resolved: z.ZodNullable<z.ZodString>;
+                    source: z.ZodEnum<{
+                        none: "none";
+                        auto: "auto";
+                        flagged: "flagged";
+                    }>;
+                }, z.core.$strip>;
+                publicEndpoint: z.ZodObject<{
+                    flagged: z.ZodNullable<z.ZodString>;
+                    resolved: z.ZodNullable<z.ZodString>;
+                    source: z.ZodEnum<{
+                        none: "none";
+                        auto: "auto";
+                        flagged: "flagged";
+                    }>;
+                }, z.core.$strip>;
+            }, z.core.$strip>;
+            appLinkHub: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>, "mutation">;
+        /**
+         * Flag (`enabled: true`) or unflag an address for a role. For a
+         * single-valued role, flagging moves the flag off every other address.
+         * `baseUrl: null` returns the role to automatic. The address must be a row
+         * of the table (detected, custom, or the app link for `notificationTaps`);
+         * `publicEndpoint` on a plain-http address is refused unless
+         * `acceptInsecureHttp`, and never takes the app link.
+         */
+        readonly setAddressRole: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            role: z.ZodEnum<{
+                appConnections: "appConnections";
+                notificationTaps: "notificationTaps";
+                internal: "internal";
+                publicEndpoint: "publicEndpoint";
             }>;
             baseUrl: z.ZodNullable<z.ZodString>;
+            enabled: z.ZodBoolean;
+            acceptInsecureHttp: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strip>, z.ZodObject<{
+            rows: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                label: z.ZodString;
+                baseUrl: z.ZodString;
+                kind: z.ZodEnum<{
+                    custom: "custom";
+                    public: "public";
+                    "lan-ipv4": "lan-ipv4";
+                    "lan-ipv6": "lan-ipv6";
+                    loopback: "loopback";
+                    "app-link": "app-link";
+                }>;
+                interfaceKind: z.ZodEnum<{
+                    public: "public";
+                    docker: "docker";
+                    loopback: "loopback";
+                    lan: "lan";
+                    wifi: "wifi";
+                    vpn: "vpn";
+                    other: "other";
+                }>;
+                plausible: z.ZodBoolean;
+                plausibleReason: z.ZodString;
+                priority: z.ZodNumber;
+                detected: z.ZodBoolean;
+                custom: z.ZodBoolean;
+                flags: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+                    appConnections: "appConnections";
+                    notificationTaps: "notificationTaps";
+                    internal: "internal";
+                    publicEndpoint: "publicEndpoint";
+                }>>>;
+                inUse: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+                    appConnections: "appConnections";
+                    notificationTaps: "notificationTaps";
+                    internal: "internal";
+                    publicEndpoint: "publicEndpoint";
+                }>>>;
+                eligible: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+                    appConnections: "appConnections";
+                    notificationTaps: "notificationTaps";
+                    internal: "internal";
+                    publicEndpoint: "publicEndpoint";
+                }>>>;
+            }, z.core.$strip>>>;
+            roles: z.ZodObject<{
+                appConnections: z.ZodObject<{
+                    flagged: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+                    resolved: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+                    source: z.ZodEnum<{
+                        none: "none";
+                        auto: "auto";
+                        flagged: "flagged";
+                    }>;
+                }, z.core.$strip>;
+                notificationTaps: z.ZodObject<{
+                    flagged: z.ZodNullable<z.ZodString>;
+                    resolved: z.ZodNullable<z.ZodString>;
+                    source: z.ZodEnum<{
+                        none: "none";
+                        auto: "auto";
+                        flagged: "flagged";
+                    }>;
+                }, z.core.$strip>;
+                internal: z.ZodObject<{
+                    flagged: z.ZodNullable<z.ZodString>;
+                    resolved: z.ZodNullable<z.ZodString>;
+                    source: z.ZodEnum<{
+                        none: "none";
+                        auto: "auto";
+                        flagged: "flagged";
+                    }>;
+                }, z.core.$strip>;
+                publicEndpoint: z.ZodObject<{
+                    flagged: z.ZodNullable<z.ZodString>;
+                    resolved: z.ZodNullable<z.ZodString>;
+                    source: z.ZodEnum<{
+                        none: "none";
+                        auto: "auto";
+                        flagged: "flagged";
+                    }>;
+                }, z.core.$strip>;
+            }, z.core.$strip>;
+            appLinkHub: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>, "mutation">;
+        /**
+         * @deprecated Read `getAddresses().roles.internal` / `.publicEndpoint`.
+         * Kept so an addon built against the D729 amendment keeps resolving:
+         * `cluster` = the `internal` role, `browser` = the `publicEndpoint` role.
+         */
+        readonly getHubAddresses: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodObject<{
             cluster: z.ZodObject<{
                 override: z.ZodNullable<z.ZodString>;
                 resolved: z.ZodNullable<z.ZodString>;
@@ -391,7 +894,7 @@ export declare const localNetworkCapability: {
                     auto: "auto";
                 }>;
             }, z.core.$strip>;
-        }, z.core.$strip>, "mutation">;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
         /**
          * Read the operator's allowlist. Empty = "auto" (no filter). Used
          * by the admin UI's address selector to seed its checkbox state.