@camstack/addon-provider-bosch 0.1.3 → 0.1.4

package/dist/account-integration-offline-C_Tvsemc.js

@@ -0,0 +1,119 @@
+const require_dist = require("./dist-BsKpHOt8.js");
+//#region src/shared/oauth-callback.ts
+/** A code on its own: no scheme, no query, no separators. */
+var BARE_CODE = /^[A-Za-z0-9._~-]+$/;
+/**
+* What a browser puts on the clipboard around the address: whitespace, quotes or angle
+* brackets, and the `Location:` / `Request URL:` label of a developer-tools header row.
+*/
+function cleanPaste(input) {
+	return input.trim().replace(/^(?:location|request url)\s*:\s*/i, "").replace(/^["'<]+|["'>]+$/g, "").trim();
+}
+function paramsOf(input) {
+	try {
+		const url = new URL(input);
+		const merged = new URLSearchParams(url.search);
+		for (const [key, value] of new URLSearchParams(url.hash.replace(/^#/, ""))) if (!merged.has(key)) merged.set(key, value);
+		return merged;
+	} catch {
+		return new URLSearchParams(input.replace(/^[?#]/, ""));
+	}
+}
+/**
+* The authorization code from whatever an operator pasted after a browser sign-in: the full
+* app-scheme address, an address copied from the browser's developer tools, a bare
+* `code=…&state=…` query, or the bare code. Anything that carries a query must carry the
+* `state` of THIS attempt; a bare code has none to check.
+*/
+function parseOAuthCallback(input, expectedState) {
+	const text = cleanPaste(input);
+	if (text.length === 0) return {
+		ok: false,
+		reason: "empty"
+	};
+	if (BARE_CODE.test(text)) return {
+		ok: true,
+		code: text,
+		params: new URLSearchParams()
+	};
+	const params = paramsOf(text);
+	if (params.has("error")) return {
+		ok: false,
+		reason: "denied"
+	};
+	const code = params.get("code");
+	if (code === null || code.length === 0) return {
+		ok: false,
+		reason: "no-code"
+	};
+	const state = params.get("state");
+	if (state === null) return {
+		ok: false,
+		reason: "state-missing"
+	};
+	if (state !== expectedState) return {
+		ok: false,
+		reason: "state-mismatch"
+	};
+	return {
+		ok: true,
+		code,
+		params
+	};
+}
+//#endregion
+//#region src/shared/account-integration-cascade.ts
+async function cascadeRemoveDevicesForIntegration(input) {
+	const { reg, devices, addonId, system, integrationId, logger } = input;
+	let removed = 0;
+	for (const d of reg.getAllForAddon(addonId)) {
+		if (d.parentDeviceId !== null) continue;
+		const cfg = await devices.loadConfig(d.id).catch(() => ({}));
+		if (cfg["system"] !== system || cfg["brokerId"] !== integrationId) continue;
+		try {
+			await devices.remove(d.id);
+			removed += 1;
+		} catch (err) {
+			logger.warn(`${system}: integration cascade-remove failed`, {
+				tags: { deviceId: d.id },
+				meta: {
+					integrationId,
+					error: require_dist.errMsg(err)
+				}
+			});
+		}
+	}
+	return removed;
+}
+//#endregion
+//#region src/shared/account-integration-offline.ts
+function setIntegrationDevicesOnline(devices, system, integrationId, online) {
+	let count = 0;
+	for (const dev of devices) {
+		if (dev.config.get("system") !== system) continue;
+		if (dev.config.get("brokerId") !== integrationId) continue;
+		if (dev.online === online) continue;
+		dev.markOnline(online);
+		count += 1;
+	}
+	return count;
+}
+//#endregion
+Object.defineProperty(exports, "cascadeRemoveDevicesForIntegration", {
+	enumerable: true,
+	get: function() {
+		return cascadeRemoveDevicesForIntegration;
+	}
+});
+Object.defineProperty(exports, "parseOAuthCallback", {
+	enumerable: true,
+	get: function() {
+		return parseOAuthCallback;
+	}
+});
+Object.defineProperty(exports, "setIntegrationDevicesOnline", {
+	enumerable: true,
+	get: function() {
+		return setIntegrationDevicesOnline;
+	}
+});

package/dist/account-integration-offline-DKdrL0V9.mjs

@@ -0,0 +1,102 @@
+import { b as errMsg } from "./dist-LJMt_ZXW.mjs";
+//#region src/shared/oauth-callback.ts
+/** A code on its own: no scheme, no query, no separators. */
+var BARE_CODE = /^[A-Za-z0-9._~-]+$/;
+/**
+* What a browser puts on the clipboard around the address: whitespace, quotes or angle
+* brackets, and the `Location:` / `Request URL:` label of a developer-tools header row.
+*/
+function cleanPaste(input) {
+	return input.trim().replace(/^(?:location|request url)\s*:\s*/i, "").replace(/^["'<]+|["'>]+$/g, "").trim();
+}
+function paramsOf(input) {
+	try {
+		const url = new URL(input);
+		const merged = new URLSearchParams(url.search);
+		for (const [key, value] of new URLSearchParams(url.hash.replace(/^#/, ""))) if (!merged.has(key)) merged.set(key, value);
+		return merged;
+	} catch {
+		return new URLSearchParams(input.replace(/^[?#]/, ""));
+	}
+}
+/**
+* The authorization code from whatever an operator pasted after a browser sign-in: the full
+* app-scheme address, an address copied from the browser's developer tools, a bare
+* `code=…&state=…` query, or the bare code. Anything that carries a query must carry the
+* `state` of THIS attempt; a bare code has none to check.
+*/
+function parseOAuthCallback(input, expectedState) {
+	const text = cleanPaste(input);
+	if (text.length === 0) return {
+		ok: false,
+		reason: "empty"
+	};
+	if (BARE_CODE.test(text)) return {
+		ok: true,
+		code: text,
+		params: new URLSearchParams()
+	};
+	const params = paramsOf(text);
+	if (params.has("error")) return {
+		ok: false,
+		reason: "denied"
+	};
+	const code = params.get("code");
+	if (code === null || code.length === 0) return {
+		ok: false,
+		reason: "no-code"
+	};
+	const state = params.get("state");
+	if (state === null) return {
+		ok: false,
+		reason: "state-missing"
+	};
+	if (state !== expectedState) return {
+		ok: false,
+		reason: "state-mismatch"
+	};
+	return {
+		ok: true,
+		code,
+		params
+	};
+}
+//#endregion
+//#region src/shared/account-integration-cascade.ts
+async function cascadeRemoveDevicesForIntegration(input) {
+	const { reg, devices, addonId, system, integrationId, logger } = input;
+	let removed = 0;
+	for (const d of reg.getAllForAddon(addonId)) {
+		if (d.parentDeviceId !== null) continue;
+		const cfg = await devices.loadConfig(d.id).catch(() => ({}));
+		if (cfg["system"] !== system || cfg["brokerId"] !== integrationId) continue;
+		try {
+			await devices.remove(d.id);
+			removed += 1;
+		} catch (err) {
+			logger.warn(`${system}: integration cascade-remove failed`, {
+				tags: { deviceId: d.id },
+				meta: {
+					integrationId,
+					error: errMsg(err)
+				}
+			});
+		}
+	}
+	return removed;
+}
+//#endregion
+//#region src/shared/account-integration-offline.ts
+function setIntegrationDevicesOnline(devices, system, integrationId, online) {
+	let count = 0;
+	for (const dev of devices) {
+		if (dev.config.get("system") !== system) continue;
+		if (dev.config.get("brokerId") !== integrationId) continue;
+		if (dev.online === online) continue;
+		dev.markOnline(online);
+		count += 1;
+	}
+	return count;
+}
+//#endregion
+export { cascadeRemoveDevicesForIntegration as n, parseOAuthCallback as r, setIntegrationDevicesOnline as t };

package/dist/{dist-B-Un7bqT.js → dist-BsKpHOt8.js}

@@ -7800,6 +7800,12 @@ function normalizeAddonInitResult(result) {
 	if (Array.isArray(result)) return { providers: result };
 	return result;
 }
+/**
+* The share-view scope kinds a `csv_*` share token can carry. The hub mints
+* and validates them (`share-token.service.ts` builds its enum from this
+* list); a data plane names the kinds it ACCEPTS in `share`.
+*/
+var SHARE_VIEW_KINDS = ["grid-view", "events-view"];
 /** The wire shape of {@link PeerBytesTicket} — see the type for what it is. */
 var PeerBytesTicketSchema = object({
 	/** `http://127.0.0.1:<port>/<token>`. One `GET` takes it. */
@@ -12487,6 +12493,229 @@ var ConvertResultSchema = object({
 		files: array(string()).readonly()
 	})).readonly()
 });
+/**
+* Zod schemas for persisted record types.
+*
+* These schemas serve as the single source of truth for types that are
+* stored in the settings-store backend and retrieved via tRPC. They
+* replace the manual TypeScript interfaces with schema-derived types,
+* enabling runtime validation when reading from the backend.
+*
+* Convention: each schema is named `<Type>Schema`, the inferred TS type
+* keeps the original name for backward compatibility.
+*/
+/**
+* Auth model (v2 — 2026-05-12 caps-only):
+*
+* Two principals:
+*   - `isAdmin: true`  — full bypass. Admin scope set is ignored.
+*   - `isAdmin: false` — every call gated by `scopes` (see TokenScope).
+*
+* No role enum. There used to be `viewer / agent / scoped` and earlier
+* `super_admin` — collapsed onto the single boolean because every
+* non-admin caller is governed by the same scope-check rules; the
+* distinction was only ever used to route role-specific procedures
+* which we no longer have. CLI / webhook integrations are `cst_*` tokens
+* with `isAdmin: false` + an explicit scope list.
+*/
+/** Per-method access flavour. Materialised on every cap method via codegen. */
+var MethodAccessSchema = _enum([
+	"view",
+	"create",
+	"delete"
+]);
+/**
+* A single scope grant. Three forms — checked in matcher with OR
+* semantics; the first match decides whether the call passes:
+*
+*   - `category` — broadest. `target: 'device' | 'system'` selects every
+*     cap with the matching `scope` declaration. New caps inherit grants
+*     automatically — adding a device cap to the codebase makes it
+*     reachable to every user with `category:device [...]` without a
+*     re-grant. Use this for "family viewer" / "operator" tiers.
+*
+*   - `addon` — every cap that ships inside a given addon id. Niche;
+*     useful when an integration needs to interact with one specific
+*     addon's surface regardless of how many caps it exports.
+*
+*   - `capability` — the most precise form. Single cap name. Use for
+*     integration tokens where you want to grant `addons.installPackage`
+*     and nothing else.
+*
+* `access` is REQUIRED with min 1 element. `admin` bypass is the
+* "give me everything" escape; there is no wildcard scope.
+*/
+var AllowedProviderSchema = union([literal("*"), array(string())]);
+var AllowedDevicesSchema = record(string(), union([literal("*"), array(string())]));
+var CapScopeSchema = _enum(["device", "system"]);
+/**
+* DeviceSelector (scope model v3 — 2026-08-12).
+*
+* A `device` grant no longer carries a frozen list of deviceIds. It carries
+* a SELECTOR the matcher resolves against the live fleet, so the grant can be
+* DYNAMIC: a `types:['camera']` selector automatically covers a camera added
+* AFTER the grant was minted — no re-grant, no re-login.
+*
+*   - `all`       — every device in the deployment. The broad viewer/operator
+*     lever without a `category` grant (a `category` grant also covers device
+*     caps that carry no deviceId; `all` is specifically the device set).
+*   - `ids`       — an explicit deviceId list. This is what a v2 `device:[…]`
+*     grant migrates to (see {@link TokenScopeSchema}); STATIC — a new camera
+*     is NOT covered until the grant is edited.
+*   - `types`     — every device of a `DeviceType` (e.g. every `camera`).
+*     DYNAMIC. A device that changes type, or a new device of the type,
+*     re-resolves on the next request.
+*   - `locations` — every device whose operator-assigned `location` label is
+*     in the set (e.g. "Garden", "Front door"). DYNAMIC. A device with a
+*     null/unset location matches NO `locations` selector.
+*/
+var DeviceSelectorSchema = discriminatedUnion("kind", [
+	object({ kind: literal("all") }),
+	object({
+		kind: literal("ids"),
+		ids: array(number().int()).min(1)
+	}),
+	object({
+		kind: literal("types"),
+		types: array(_enum(DeviceType)).min(1)
+	}),
+	object({
+		kind: literal("locations"),
+		locations: array(string().min(1)).min(1)
+	})
+]);
+var DeviceTokenScopeSchema = object({
+	type: literal("device"),
+	/** The device SET this grant covers — resolved against the live fleet. */
+	selector: DeviceSelectorSchema,
+	access: array(MethodAccessSchema).min(1),
+	/**
+	* Whether a grant on a PARENT device transparently covers its accessory
+	* CHILDREN (siren / floodlight / PIR) via the persisted-parentage walk.
+	* Direction is parent → children ONLY.
+	*
+	* Absent → the matcher DERIVES it from the access flavour: `view`
+	* inherits (a camera viewer sees the camera's accessories), `create` /
+	* `delete` do NOT (actuating/removing a child is an explicit act the
+	* operator must grant on the child, not inherit from the parent). Set it
+	* explicitly to override that default per grant.
+	*/
+	includeLinked: boolean().optional()
+});
+/**
+* v2 → v3 lazy migration. A pre-v3 `device` grant carried
+* `targets: string[]` (stringified deviceIds); it rewrites to the equivalent
+* `selector: {kind:'ids', ids}`. Applied as a `preprocess` so it runs on
+* EVERY parse path — stored records AND the JWT-carried scope arrays
+* normalised at the request boundary ({@link normalizeTokenScopes} in
+* `device-selector.ts`). Chosen over a one-time DB migration because a
+* migration cannot reach a JWT already in a client's hands; parse-time
+* migration covers both without a flag day. No cast — the raw object is read
+* through `Reflect.get` (its static type is `unknown`).
+*/
+function migrateLegacyTokenScope(raw) {
+	if (raw === null || typeof raw !== "object" || Array.isArray(raw)) return raw;
+	if (Reflect.get(raw, "type") !== "device") return raw;
+	if (Reflect.get(raw, "selector") !== void 0) return raw;
+	const targets = Reflect.get(raw, "targets");
+	if (!Array.isArray(targets)) return raw;
+	return {
+		type: "device",
+		selector: {
+			kind: "ids",
+			ids: targets.map((t) => typeof t === "string" ? Number(t) : t).filter((n) => typeof n === "number" && Number.isInteger(n))
+		},
+		access: Reflect.get(raw, "access")
+	};
+}
+var TokenScopeSchema = preprocess(migrateLegacyTokenScope, discriminatedUnion("type", [
+	object({
+		type: literal("category"),
+		target: CapScopeSchema,
+		access: array(MethodAccessSchema).min(1)
+	}),
+	object({
+		type: literal("capability"),
+		target: string(),
+		access: array(MethodAccessSchema).min(1)
+	}),
+	object({
+		type: literal("addon"),
+		target: string(),
+		access: array(MethodAccessSchema).min(1)
+	}),
+	DeviceTokenScopeSchema
+]));
+object({
+	id: string(),
+	username: string(),
+	passwordHash: string(),
+	/**
+	* Admin bypass. When true, the middleware skips the scope-access
+	* check entirely. There is no other axis of privilege; the legacy
+	* role enum collapsed onto this boolean in v2.
+	*/
+	isAdmin: boolean().default(false),
+	allowedProviders: AllowedProviderSchema,
+	allowedDevices: AllowedDevicesSchema,
+	/**
+	* Scopes granted to this user. Admins bypass; their `scopes` is
+	* ignored. Non-admins without scopes are locked out of every
+	* protected call.
+	*/
+	scopes: array(TokenScopeSchema).default([]),
+	createdAt: number(),
+	updatedAt: number()
+});
+object({
+	id: string(),
+	label: string(),
+	isAdmin: boolean().default(false),
+	allowedProviders: AllowedProviderSchema,
+	allowedDevices: AllowedDevicesSchema,
+	tokenHash: string(),
+	tokenPrefix: string(),
+	createdAt: number(),
+	lastUsedAt: number().optional()
+});
+object({
+	id: string(),
+	userId: string(),
+	name: string(),
+	tokenHash: string(),
+	tokenPrefix: string(),
+	scopes: array(TokenScopeSchema),
+	expiresAt: number().nullish(),
+	lastUsedAt: number().nullish(),
+	createdAt: number()
+});
+/** What a share-view grant lets its holder see. */
+var ShareViewGrantSchema = object({
+	kind: _enum(SHARE_VIEW_KINDS),
+	deviceIds: array(number().int().nonnegative()).min(1).max(64),
+	/** Talk-back, opt-in at mint time; absent means off. */
+	talk: boolean().optional()
+});
+var ShareViewScopeSchema = object({
+	type: literal("share-view"),
+	grant: ShareViewGrantSchema
+});
+var AddonRoutesScopeSchema = object({
+	type: literal("addon-routes"),
+	access: array(MethodAccessSchema).min(1)
+});
+var CredentialScopeSchema = union([
+	literal("*"),
+	ShareViewScopeSchema,
+	AddonRoutesScopeSchema,
+	TokenScopeSchema
+]);
+object({
+	kind: literal("credential"),
+	sub: string().min(1),
+	jti: string().min(16),
+	scopes: array(CredentialScopeSchema).min(1)
+});
 _enum(["new-session", "step-up"]);
 /** The languages the hub's app landing pages are written in (D858). */
 var AppPageLangSchema = _enum(["en", "it"]);
@@ -43981,202 +44210,6 @@ method(object({}), object({ rules: array(NcRuleSchema) }), { auth: "admin" }), m
 	auth: "admin"
 }), method(NcAlarmSensorsInputSchema, NcAlarmSensorsSchema, { auth: "admin" });
 /**
-* Zod schemas for persisted record types.
-*
-* These schemas serve as the single source of truth for types that are
-* stored in the settings-store backend and retrieved via tRPC. They
-* replace the manual TypeScript interfaces with schema-derived types,
-* enabling runtime validation when reading from the backend.
-*
-* Convention: each schema is named `<Type>Schema`, the inferred TS type
-* keeps the original name for backward compatibility.
-*/
-/**
-* Auth model (v2 — 2026-05-12 caps-only):
-*
-* Two principals:
-*   - `isAdmin: true`  — full bypass. Admin scope set is ignored.
-*   - `isAdmin: false` — every call gated by `scopes` (see TokenScope).
-*
-* No role enum. There used to be `viewer / agent / scoped` and earlier
-* `super_admin` — collapsed onto the single boolean because every
-* non-admin caller is governed by the same scope-check rules; the
-* distinction was only ever used to route role-specific procedures
-* which we no longer have. CLI / webhook integrations are `cst_*` tokens
-* with `isAdmin: false` + an explicit scope list.
-*/
-/** Per-method access flavour. Materialised on every cap method via codegen. */
-var MethodAccessSchema = _enum([
-	"view",
-	"create",
-	"delete"
-]);
-/**
-* A single scope grant. Three forms — checked in matcher with OR
-* semantics; the first match decides whether the call passes:
-*
-*   - `category` — broadest. `target: 'device' | 'system'` selects every
-*     cap with the matching `scope` declaration. New caps inherit grants
-*     automatically — adding a device cap to the codebase makes it
-*     reachable to every user with `category:device [...]` without a
-*     re-grant. Use this for "family viewer" / "operator" tiers.
-*
-*   - `addon` — every cap that ships inside a given addon id. Niche;
-*     useful when an integration needs to interact with one specific
-*     addon's surface regardless of how many caps it exports.
-*
-*   - `capability` — the most precise form. Single cap name. Use for
-*     integration tokens where you want to grant `addons.installPackage`
-*     and nothing else.
-*
-* `access` is REQUIRED with min 1 element. `admin` bypass is the
-* "give me everything" escape; there is no wildcard scope.
-*/
-var AllowedProviderSchema = union([literal("*"), array(string())]);
-var AllowedDevicesSchema = record(string(), union([literal("*"), array(string())]));
-var CapScopeSchema = _enum(["device", "system"]);
-/**
-* DeviceSelector (scope model v3 — 2026-08-12).
-*
-* A `device` grant no longer carries a frozen list of deviceIds. It carries
-* a SELECTOR the matcher resolves against the live fleet, so the grant can be
-* DYNAMIC: a `types:['camera']` selector automatically covers a camera added
-* AFTER the grant was minted — no re-grant, no re-login.
-*
-*   - `all`       — every device in the deployment. The broad viewer/operator
-*     lever without a `category` grant (a `category` grant also covers device
-*     caps that carry no deviceId; `all` is specifically the device set).
-*   - `ids`       — an explicit deviceId list. This is what a v2 `device:[…]`
-*     grant migrates to (see {@link TokenScopeSchema}); STATIC — a new camera
-*     is NOT covered until the grant is edited.
-*   - `types`     — every device of a `DeviceType` (e.g. every `camera`).
-*     DYNAMIC. A device that changes type, or a new device of the type,
-*     re-resolves on the next request.
-*   - `locations` — every device whose operator-assigned `location` label is
-*     in the set (e.g. "Garden", "Front door"). DYNAMIC. A device with a
-*     null/unset location matches NO `locations` selector.
-*/
-var DeviceSelectorSchema = discriminatedUnion("kind", [
-	object({ kind: literal("all") }),
-	object({
-		kind: literal("ids"),
-		ids: array(number().int()).min(1)
-	}),
-	object({
-		kind: literal("types"),
-		types: array(_enum(DeviceType)).min(1)
-	}),
-	object({
-		kind: literal("locations"),
-		locations: array(string().min(1)).min(1)
-	})
-]);
-var DeviceTokenScopeSchema = object({
-	type: literal("device"),
-	/** The device SET this grant covers — resolved against the live fleet. */
-	selector: DeviceSelectorSchema,
-	access: array(MethodAccessSchema).min(1),
-	/**
-	* Whether a grant on a PARENT device transparently covers its accessory
-	* CHILDREN (siren / floodlight / PIR) via the persisted-parentage walk.
-	* Direction is parent → children ONLY.
-	*
-	* Absent → the matcher DERIVES it from the access flavour: `view`
-	* inherits (a camera viewer sees the camera's accessories), `create` /
-	* `delete` do NOT (actuating/removing a child is an explicit act the
-	* operator must grant on the child, not inherit from the parent). Set it
-	* explicitly to override that default per grant.
-	*/
-	includeLinked: boolean().optional()
-});
-/**
-* v2 → v3 lazy migration. A pre-v3 `device` grant carried
-* `targets: string[]` (stringified deviceIds); it rewrites to the equivalent
-* `selector: {kind:'ids', ids}`. Applied as a `preprocess` so it runs on
-* EVERY parse path — stored records AND the JWT-carried scope arrays
-* normalised at the request boundary ({@link normalizeTokenScopes} in
-* `device-selector.ts`). Chosen over a one-time DB migration because a
-* migration cannot reach a JWT already in a client's hands; parse-time
-* migration covers both without a flag day. No cast — the raw object is read
-* through `Reflect.get` (its static type is `unknown`).
-*/
-function migrateLegacyTokenScope(raw) {
-	if (raw === null || typeof raw !== "object" || Array.isArray(raw)) return raw;
-	if (Reflect.get(raw, "type") !== "device") return raw;
-	if (Reflect.get(raw, "selector") !== void 0) return raw;
-	const targets = Reflect.get(raw, "targets");
-	if (!Array.isArray(targets)) return raw;
-	return {
-		type: "device",
-		selector: {
-			kind: "ids",
-			ids: targets.map((t) => typeof t === "string" ? Number(t) : t).filter((n) => typeof n === "number" && Number.isInteger(n))
-		},
-		access: Reflect.get(raw, "access")
-	};
-}
-var TokenScopeSchema = preprocess(migrateLegacyTokenScope, discriminatedUnion("type", [
-	object({
-		type: literal("category"),
-		target: CapScopeSchema,
-		access: array(MethodAccessSchema).min(1)
-	}),
-	object({
-		type: literal("capability"),
-		target: string(),
-		access: array(MethodAccessSchema).min(1)
-	}),
-	object({
-		type: literal("addon"),
-		target: string(),
-		access: array(MethodAccessSchema).min(1)
-	}),
-	DeviceTokenScopeSchema
-]));
-object({
-	id: string(),
-	username: string(),
-	passwordHash: string(),
-	/**
-	* Admin bypass. When true, the middleware skips the scope-access
-	* check entirely. There is no other axis of privilege; the legacy
-	* role enum collapsed onto this boolean in v2.
-	*/
-	isAdmin: boolean().default(false),
-	allowedProviders: AllowedProviderSchema,
-	allowedDevices: AllowedDevicesSchema,
-	/**
-	* Scopes granted to this user. Admins bypass; their `scopes` is
-	* ignored. Non-admins without scopes are locked out of every
-	* protected call.
-	*/
-	scopes: array(TokenScopeSchema).default([]),
-	createdAt: number(),
-	updatedAt: number()
-});
-object({
-	id: string(),
-	label: string(),
-	isAdmin: boolean().default(false),
-	allowedProviders: AllowedProviderSchema,
-	allowedDevices: AllowedDevicesSchema,
-	tokenHash: string(),
-	tokenPrefix: string(),
-	createdAt: number(),
-	lastUsedAt: number().optional()
-});
-object({
-	id: string(),
-	userId: string(),
-	name: string(),
-	tokenHash: string(),
-	tokenPrefix: string(),
-	scopes: array(TokenScopeSchema),
-	expiresAt: number().nullish(),
-	lastUsedAt: number().nullish(),
-	createdAt: number()
-});
-/**
 * `oauth-integration` — a collection cap by which an addon declares
 * itself a linkable OAuth client of the hub's core `/oauth2/*` server.
 * Each provider returns a static descriptor; the core enumerates them