@camstack/types 1.2.243 → 1.2.244

package/dist/index.js

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_sleep = require("./sleep-mVRRyKVq.js");
+const require_sleep = require("./sleep-Da9UCU5_.js");
 const require_event_category = require("./event-category-BVfsrBYA.js");
 const require_canonical_hash = require("./canonical-hash-CSE4ioRi.js");
 const require_enums = require("./enums.js");
@@ -11553,6 +11553,248 @@ var deviceAdoptionCapability = {
 	}
 };
 //#endregion
+//#region src/capabilities/device-admin-link.cap.ts
+/**
+* device-admin-link — "this device has a management page of its own, and here
+* is its address".
+*
+* ## Why this is not a `deviceConfig` cap
+*
+* There is nothing to edit. A `deviceConfig` cap (D14) exists so the framework
+* can DERIVE a settings form from `getOptions` + `getStatus` and route a flat
+* patch back through a setter; it costs a `builderId` reducer in
+* `device-config-contribution.ts` and a `*-config-schema.ts` beside it, and it
+* renders a form section. This cap answers ONE question with ONE read and
+* renders a button. Nothing about it is a form, so it carries no `deviceConfig`
+* block, no `settings`, no `runtimeState` and no reducer — exactly like
+* `reboot`, the other pure-RPC device-native cap.
+*
+* ## Absent, and the difference between "no page" and "we cannot say"
+*
+* The two are answered at DIFFERENT layers, on purpose:
+*
+*  - **"We cannot say"** → the provider never registers the cap for that
+*    device. A VeSync humidifier, a Petkit feeder, a Dreame vacuum and a Dreo
+*    fan are reached only through a vendor cloud; there is no address to hand
+*    out and no page to open. A Tuya plug, a Wyze camera and a Gree air
+*    conditioner DO have a LAN IP, and still have no HTTP management page
+*    behind it. None of them register, so `deviceManager.getBindings` never
+*    lists the cap and no surface asks.
+*  - **"This device has no page, and I know that"** → the provider registers
+*    and `getAdminLink` returns `null`. This is the answer for a device whose
+*    sibling DOES have a page: a Reolink battery camera reached over UDP by
+*    `uid` with a blank `host`, an Ecowitt gateway configured in `listener`
+*    transport, a Home Assistant broker authenticated by supervisor token
+*    (which carries no `baseUrl` at all).
+*
+* Both draw NOTHING. A button that opens a browser error is worse than no
+* button, and D62 is the same rule from the other side: an off switch is
+* reported off, never made to look broken. There is no third state where the
+* UI renders a disabled button "because the device might have a page".
+*
+* ## The URL never carries credentials
+*
+* Not in userinfo, not in a query string. Every provider builds through
+* `buildDeviceAdminUrl` (`device-admin-link-url.ts`), which takes host, port,
+* scheme and path as separate arguments — there is no parameter a secret could
+* arrive in — and re-checks its own output for the `scheme://user:pass@` shape
+* that `scripts/check-no-credential-urls-in-fixtures.ts` bans from recorded
+* output. `scripts/check-admin-link-builder-is-the-only-url-source.ts` is what
+* keeps providers from hand-rolling one anyway.
+*
+* This matters here more than anywhere else in the repo, because every provider
+* that knows a device's host knows its PASSWORD too: `{ host, port, username,
+* password }` sit in one object on Hikvision, Amcrest, Reolink and ONVIF alike,
+* and `http://admin:hunter2@192.168.50.139/` is a URL a browser accepts. The
+* camera's own page will ask for its own login. That is correct, and pre-
+* filling it is the operator's business, not ours.
+*
+* ## It is a LAN fact
+*
+* The URL addresses the device where the NODE can see it. It is not proxied,
+* not made reachable from outside, and not sent anywhere. A surface renders it
+* as a link the operator's own browser follows, on the operator's own network,
+* or renders nothing.
+*/
+/**
+* Whose page is it. The distinction is for the OPERATOR, who needs to know
+* before clicking whether he is about to land on a camera's own web server or
+* inside Home Assistant.
+*/
+var AdminLinkTargetEnum = zod.z.enum(["device", "integration"]);
+var DeviceAdminLinkSchema = zod.z.object({
+	/**
+	* Absolute `http(s)://` URL. Built by `buildDeviceAdminUrl` and therefore
+	* free of userinfo and of any credential-shaped query key.
+	*/
+	url: zod.z.string(),
+	/**
+	* What the surface calls it — "Web UI", "Home Assistant", "UniFi controller".
+	* The PROVIDER names it, because only the provider knows what the page is;
+	* a UI that invented the label from the addon id would call the Home
+	* Assistant device page "Provider Homeassistant".
+	*/
+	label: zod.z.string(),
+	target: AdminLinkTargetEnum,
+	/**
+	* Host the URL points at, without scheme, port or path — for the tooltip, so
+	* an operator can see WHERE the button goes before he follows it. Redundant
+	* with `url` by construction; carried separately so no surface has to parse
+	* a URL to show it.
+	*/
+	host: zod.z.string()
+});
+var deviceAdminLinkCapability = {
+	name: "device-admin-link",
+	scope: "device",
+	deviceNative: true,
+	mode: "singleton",
+	methods: { 
+	/**
+	* The device's management page, or `null` when this device has none.
+	*
+	* `auth: 'admin'` deliberately. This is administration, not actuation —
+	* the same bucket as `reboot` and `camera-credentials`, and explicitly NOT
+	* the actuation set `scripts/check-actuation-not-admin.ts` protects (D403).
+	* The URL is also a statement about the LAN, which a household member with
+	* a `view` grant on a light has no reason to be handed.
+	*
+	* The surfaces gate on the QUERY, never on a role they guessed: a caller
+	* without the right loses the query and draws nothing, which is the same
+	* thing a device with no page draws. There is no path on which a button
+	* appears and then fails — the D403 failure mode, from the other end.
+	*/
+getAdminLink: require_sleep.method(zod.z.object({ deviceId: zod.z.number().int().nonnegative() }), DeviceAdminLinkSchema.nullable(), { auth: "admin" }) }
+};
+//#endregion
+//#region src/capabilities/device-admin-link-url.ts
+/**
+* Query keys that may never appear on an admin link. A credential smuggled as
+* `?password=` is the same leak as userinfo, in a form the userinfo check
+* cannot see: it survives copy-paste, referrer headers and proxy logs
+* identically.
+*/
+var CREDENTIAL_QUERY_KEYS = [
+	"password",
+	"passwd",
+	"pwd",
+	"pass",
+	"user",
+	"username",
+	"usr",
+	"login",
+	"token",
+	"access_token",
+	"auth",
+	"authorization",
+	"apikey",
+	"api_key",
+	"secret",
+	"credential",
+	"credentials",
+	"session",
+	"sessionid",
+	"key"
+];
+/**
+* The same userinfo shape `scripts/check-no-credential-urls-in-fixtures.ts`
+* scans recorded fixtures for, applied to what we are about to EMIT. Kept
+* structurally identical on purpose: a URL this function returns is a URL that
+* guard would pass.
+*/
+var CREDENTIAL_URL = /[a-z][a-z0-9+.-]*:\/\/[^/\s:@'"]+:[^/\s:@'"]+@/i;
+/** A host that is safe to place in an authority component verbatim. */
+var PLAIN_HOST = /^[a-zA-Z0-9._-]+$/;
+/** A bracketed IPv6 literal, the only other authority form we emit. */
+var IPV6_HOST = /^\[[0-9a-fA-F:.]+\]$/;
+function defaultPortFor(scheme) {
+	return scheme === "https" ? 443 : 80;
+}
+/**
+* Build the admin-page URL, or refuse by name.
+*
+* The refusal is never thrown: a provider answering "no page for this device"
+* is an ordinary answer (`getAdminLink` → `null`), and a throw here would turn
+* a missing host on one device into a failed query for the whole surface.
+*/
+function buildDeviceAdminUrl(parts) {
+	const host = parts.host.trim();
+	if (host.length === 0) return {
+		ok: false,
+		reason: "empty-host"
+	};
+	if (host.includes("@")) return {
+		ok: false,
+		reason: "host-carries-userinfo"
+	};
+	if (!PLAIN_HOST.test(host) && !IPV6_HOST.test(host)) return {
+		ok: false,
+		reason: "host-not-plain"
+	};
+	if (parts.port !== null) {
+		if (!Number.isInteger(parts.port) || parts.port < 1 || parts.port > 65535) return {
+			ok: false,
+			reason: "port-out-of-range"
+		};
+	}
+	if (!parts.path.startsWith("/")) return {
+		ok: false,
+		reason: "path-not-absolute"
+	};
+	const query = parts.query ?? {};
+	for (const key of Object.keys(query)) if (CREDENTIAL_QUERY_KEYS.includes(key.toLowerCase())) return {
+		ok: false,
+		reason: "credential-query-key"
+	};
+	const authority = parts.port === null || parts.port === defaultPortFor(parts.scheme) ? host : `${host}:${String(parts.port)}`;
+	const search = new URLSearchParams();
+	for (const [key, value] of Object.entries(query)) search.append(key, value);
+	const suffix = search.size > 0 ? `?${search.toString()}` : "";
+	const url = `${parts.scheme}://${authority}${parts.path}${suffix}`;
+	if (CREDENTIAL_URL.test(url)) return {
+		ok: false,
+		reason: "userinfo-in-result"
+	};
+	return {
+		ok: true,
+		url
+	};
+}
+function parseAdminBase(baseUrl) {
+	const raw = baseUrl.trim();
+	if (raw.length === 0) return {
+		ok: false,
+		reason: "empty"
+	};
+	let parsed;
+	try {
+		parsed = new URL(raw);
+	} catch {
+		return {
+			ok: false,
+			reason: "unparseable"
+		};
+	}
+	if (parsed.username !== "" || parsed.password !== "") return {
+		ok: false,
+		reason: "base-carries-userinfo"
+	};
+	if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return {
+		ok: false,
+		reason: "scheme-not-http"
+	};
+	const scheme = parsed.protocol === "https:" ? "https" : "http";
+	const port = parsed.port === "" ? null : Number(parsed.port);
+	const basePath = parsed.pathname === "/" ? "" : parsed.pathname.replace(/\/+$/, "");
+	return {
+		ok: true,
+		host: parsed.hostname,
+		port,
+		scheme,
+		basePath
+	};
+}
+//#endregion
 //#region src/capabilities/device-export.cap.ts
 /**
 * `device-export` — collection cap for addons that export camstack
@@ -30623,6 +30865,632 @@ var dayNightCapability = {
 	volatileStateFields: ["lastFetchedAt"]
 };
 //#endregion
+//#region src/capabilities/recording-onboard.cap.ts
+/**
+* Vendor-neutral **onboard** recording + storage cap — what the CAMERA
+* writes to the CAMERA's own card, on the camera's own schedule.
+*
+* This is NOT `recording.cap.ts`. That one is CamStack's recorder: our
+* footage ledger, our storage locations, our retention. This one has a
+* different authority — the camera's firmware — and per D62 it stores
+* nothing of its own. Every value here is read from the camera and every
+* write goes back to the camera; there is no CamStack-side mirror that
+* could disagree with the device.
+*
+* ## One shape, two firmwares
+*
+* Measured 2026-09-22 against the live fleet:
+*
+* | fact | Hikvision (ISAPI) | Reolink (Baichuan) |
+* | --- | --- | --- |
+* | storage | `ContentMgmt/Storage` `<hdd>` rows: status, capacity, freeSpace (MB) | `getHddInfoList` (cmd 102): `mount`, `format`, `capacity` GB + `capacityM` MB remainder |
+* | tracks | several (101 **and** 103 on both 1436 and 3833), each with its own schedule | one per channel |
+* | schedule | per track, 7 `ScheduleAction` blocks: DayOfWeek + TimeOfDay range + ONE `ActionRecordingMode` | per trigger type, a 168-char weekly HOUR mask |
+* | triggers | `CMR`, `MOTION` | `Normal`, `MD`, `people`, `vehicle`, `dog_cat`, `crossline`, `intrude`, `loitering` |
+* | pre-record | `PreRecordTimeSeconds` | `preRecordTime` |
+* | post-record | `PostRecordTimeSeconds` | `recordDelayTime` |
+* | overwrite | per track `LoopEnable` | `cycle`, with `cycleList` enumerating the accepted values |
+* | segment length | not exposed on V5.7.1 | `packageTime` (minutes) |
+*
+* The two schedule models look different and are the same thing in
+* different coordinates: both answer "for this trigger, during which
+* weekly windows does the camera record". {@link RecordWindow} is that
+* question in one shape — Hikvision's ranges map straight onto it,
+* Reolink's mask expands into hour-aligned windows.
+*
+* ## Union, not intersection
+*
+* **The same fields exist on every camera.** What differs per device is
+* which VALUES that device accepts, and that is what {@link
+* RecordingOnboardOptions} reports — a `{ readable, writable, reason }`
+* per field plus the schedule's own limits. A control a camera cannot
+* honour is rendered DISABLED WITH ITS REASON, never missing and never
+* dead: disabled must not look like broken.
+*
+* ## Refusal by name
+*
+* A write a camera cannot honour is refused with a sentence the operator
+* can read — never accepted and dropped. Both providers refuse through
+* {@link describeOnboardRefusal}, so the vocabulary is one function and
+* one test, not two hand-written vendor opinions.
+*
+* Follows the D14 `deviceConfig` archetype (see `stream-params.cap.ts`):
+* `getOptions` advertises per-camera availability, `getStatus` (auto-
+* injected from `status`) reports the live values, and a single
+* `setSettings` mutation applies a partial change. No hand-written
+* settings-contribution methods.
+*/
+/**
+* What makes the camera start recording during a window.
+*
+* The union of both vendors' vocabularies. `continuous` is Hikvision's
+* `CMR` and Reolink's `Normal`; `motion` is `MOTION` / `MD`. The
+* object-class triggers are Reolink-only today and the smart-event ones
+* (`lineCrossing`, `intrusion`, `loitering`) are Reolink-only on the
+* firmwares measured — a camera that cannot record on a trigger simply
+* does not list it in `options.schedule.triggers`, and a window naming
+* it is REFUSED, not dropped.
+*/
+var RecordTriggerSchema = zod.z.enum([
+	"continuous",
+	"motion",
+	"person",
+	"vehicle",
+	"animal",
+	"lineCrossing",
+	"intrusion",
+	"loitering",
+	"alarmInput"
+]);
+/**
+* One weekly recording window: "on `day`, from `startMinute` to
+* `endMinute`, record on `trigger`".
+*
+* `day` is 0 = Monday … 6 = Sunday (ISO order, which is also the order
+* both firmwares enumerate). Minutes are local camera time since
+* midnight; `endMinute` may be 1440, meaning end of day — that is
+* Hikvision's literal `24:00` and Reolink's 24th mask slot, and
+* collapsing it to 0 would turn a whole-day window into an empty one.
+*/
+var RecordWindowSchema = zod.z.object({
+	trigger: RecordTriggerSchema,
+	day: zod.z.number().int().min(0).max(6),
+	startMinute: zod.z.number().int().min(0).max(1439),
+	endMinute: zod.z.number().int().min(1).max(1440)
+});
+/** Status of one physical volume, as the camera itself describes it. */
+var OnboardStorageVolumeSchema = zod.z.object({
+	/** The camera's own id for the volume (`hdd/id`, Reolink `HddInfo/number`). */
+	id: zod.z.string(),
+	/** The camera's own name for it, when it gives one (`hddName`). */
+	label: zod.z.string().optional(),
+	status: zod.z.enum([
+		"ok",
+		"unformatted",
+		"error",
+		"offline",
+		"unknown"
+	]),
+	/**
+	* Total size in MB, or **null when the camera did not say**.
+	*
+	* Never 0 for an unreadable value: a measurement that failed is not a
+	* measurement (D393), and a card whose size is unknown must not be
+	* rendered as a card of size zero.
+	*/
+	capacityMb: zod.z.number().nullable(),
+	/**
+	* Free space in MB, or null when unknown.
+	*
+	* **Not a proxy for "has footage".** Measured 2026-09-22: 1436 and
+	* 1439 both report exactly 11776 MB free — the fixed reserve a looping
+	* card converges on once it has wrapped. At loop steady state the
+	* number is identical whether the camera recorded yesterday or stopped
+	* a month ago.
+	*/
+	freeMb: zod.z.number().nullable(),
+	/** True when the camera reports the volume writable (`property` RW). */
+	writable: zod.z.boolean().optional()
+});
+/**
+* Whether the camera has usable onboard storage.
+*
+* Three states, never two: an unreadable answer is `unknown`, never
+* folded into `absent`. Folding a failed read into "no card" is how a
+* healthy camera gets reported as broken, and the inverse is how a
+* camera with no card reports `ok` and then an empty list (D393).
+*/
+var OnboardStorageSchema = zod.z.discriminatedUnion("kind", [
+	zod.z.object({
+		kind: zod.z.literal("present"),
+		volumes: zod.z.array(OnboardStorageVolumeSchema)
+	}),
+	zod.z.object({
+		kind: zod.z.literal("absent"),
+		reason: zod.z.string()
+	}),
+	zod.z.object({
+		kind: zod.z.literal("unknown"),
+		reason: zod.z.string()
+	})
+]);
+/**
+* One recording track the camera exposes. Read-only.
+*
+* Hikvision lists several — 1436 and 3833 each list 101 AND 103, with
+* DIFFERENT schedules (101 MOTION all day, 103 CMR 00:05–23:57) — so a
+* cap that reported one number for "the schedule" would be lying on
+* every Hikvision in the fleet. Reolink has exactly one per channel.
+*
+* There is deliberately **no `framerate`**. Hikvision declares it in the
+* track `Description` and it is WRONG: 1436 says `2.260000 fps` while
+* the media measures 12.55 fps. `codec` and `resolution` from the same
+* string ARE right — those are the only two worth surfacing.
+*/
+var OnboardRecordTrackSchema = zod.z.object({
+	id: zod.z.string(),
+	enabled: zod.z.boolean(),
+	isVideo: zod.z.boolean(),
+	/** From the camera's own track description. Null when it does not say. */
+	codec: zod.z.string().nullable(),
+	resolution: zod.z.string().nullable(),
+	/** Per-track overwrite flag, where the firmware keeps it per track. */
+	overwriteWhenFull: zod.z.boolean().nullable()
+});
+/**
+* What the camera is doing with its own storage, right now.
+*
+* Every scalar is nullable and **null means the camera did not answer**,
+* never a default. A form that seeds `0` from an unanswered read invites
+* the operator to save that 0 back onto the camera.
+*/
+var RecordingOnboardStatusSchema = zod.z.object({
+	storage: OnboardStorageSchema,
+	tracks: zod.z.array(OnboardRecordTrackSchema),
+	/**
+	* The track the write path targets — the enabled VIDEO one. Null when
+	* no track could be identified, which is itself a refusal reason.
+	*/
+	primaryTrackId: zod.z.string().nullable(),
+	/** Master "record to the card at all" switch. */
+	enabled: zod.z.boolean().nullable(),
+	overwriteWhenFull: zod.z.boolean().nullable(),
+	preRecordSec: zod.z.number().nullable(),
+	postRecordSec: zod.z.number().nullable(),
+	/** Length of one recorded file, in minutes. */
+	segmentMinutes: zod.z.number().nullable(),
+	/** The primary track's weekly windows, flattened. */
+	windows: zod.z.array(RecordWindowSchema),
+	/**
+	* How many windows the camera described that CamStack could NOT read —
+	* an unrecognised trigger, an unparseable clock, a weekday it does not
+	* name.
+	*
+	* A dropped window is work the reader threw away, and a schedule that
+	* silently shows fewer rows than the camera holds is how an operator
+	* saves back a schedule shorter than the one they were looking at
+	* (D391). Non-zero means the window list is INCOMPLETE and a write
+	* that replaces it would delete what was not shown — which is why a
+	* provider reporting a non-zero count also reports the schedule as not
+	* writable.
+	*/
+	unreadableWindows: zod.z.number(),
+	/**
+	* The camera is scheduled to record and has NO usable storage.
+	*
+	* A first-class fact because it is the fleet's most common silent
+	* defect: measured 2026-09-22, 1441 and 3831 are both motion-recording
+	* to a card that is not there. Neither the schedule nor the storage
+	* read says anything wrong on its own; only the pair does.
+	*/
+	recordingToNowhere: zod.z.boolean(),
+	lastFetchedAt: zod.z.number()
+});
+/** Numeric range descriptor — `{ min, max, step }` per the getOptions convention. */
+var RangeSchema = zod.z.object({
+	min: zod.z.number(),
+	max: zod.z.number(),
+	step: zod.z.number()
+});
+/**
+* The values a camera actually takes for a numeric field, when they are a SET
+* rather than a range.
+*
+* `{min,max,step}` cannot say what these two firmwares do. Measured on 1436
+* (I91DN) on 2026-09-22 by writing each value and reading it back:
+*
+* - pre-record: `0, 5, 10, 15, 20, 25, 30` and `2147483647` (INT32_MAX, the
+*   camera's "no limit" — `-1` and `4294967295` both land on it);
+* - post-record: `5, 10, 30, 60, 120, 300, 600`.
+*
+* Neither is expressible as a step: the first has a sentinel two billion away
+* from its neighbours, the second doubles and then jumps. A range that tried
+* would forbid values the camera takes AND permit values it silently replaces
+* with 5 — wrong in both directions at once.
+*
+* `sentinel` names the member that is not a duration, so a surface can render
+* "no limit" instead of `2147483647` seconds.
+*/
+var AllowedValuesSchema = zod.z.object({
+	values: zod.z.array(zod.z.number()).min(1),
+	sentinel: zod.z.object({
+		value: zod.z.number(),
+		meaning: zod.z.enum(["no-limit", "disabled"])
+	}).optional()
+});
+/**
+* Per-field availability on ONE camera.
+*
+* The field exists on every camera — this says whether this one can be
+* read and whether it can be written, and `reason` says why not when
+* either is false. The UI renders the control DISABLED with the reason
+* rather than hiding it, so a limitation is legible instead of looking
+* like a missing feature.
+*/
+var OnboardFieldSupportSchema = zod.z.object({
+	readable: zod.z.boolean(),
+	writable: zod.z.boolean(),
+	/** Required whenever `readable` or `writable` is false. */
+	reason: zod.z.string().optional()
+});
+/** What this camera's schedule model can express. */
+var OnboardScheduleSupportSchema = zod.z.object({
+	support: OnboardFieldSupportSchema,
+	/**
+	* The smallest time step the camera can express, in minutes.
+	*
+	* Hikvision takes arbitrary minutes (`00:05:00`–`23:57:00` observed on
+	* 1436's track 103). Reolink's schedule is a 7×24 HOUR mask, so 60. A
+	* window whose edges are not a multiple of this is REFUSED rather than
+	* quietly rounded — rounding is how an operator's 06:30 becomes 06:00
+	* and nothing says so.
+	*/
+	granularityMinutes: zod.z.number(),
+	/** Triggers this camera can record on. A window naming another is refused. */
+	triggers: zod.z.array(RecordTriggerSchema),
+	/**
+	* False when the camera stores ONE trigger per time range, so two
+	* windows overlapping on the same day cannot carry different triggers.
+	* True on Reolink, whose mask is per-trigger and independent.
+	*/
+	supportsOverlappingTriggers: zod.z.boolean()
+});
+var RecordingOnboardOptionsSchema = zod.z.object({
+	enabled: OnboardFieldSupportSchema,
+	overwriteWhenFull: OnboardFieldSupportSchema,
+	preRecordSec: OnboardFieldSupportSchema,
+	preRecordSecRange: RangeSchema.optional(),
+	/** Preferred over the range when the camera takes a SET, not a span. */
+	preRecordSecAllowed: AllowedValuesSchema.optional(),
+	postRecordSec: OnboardFieldSupportSchema,
+	postRecordSecRange: RangeSchema.optional(),
+	/** Preferred over the range when the camera takes a SET, not a span. */
+	postRecordSecAllowed: AllowedValuesSchema.optional(),
+	segmentMinutes: OnboardFieldSupportSchema,
+	segmentMinutesRange: RangeSchema.optional(),
+	/** Preferred over the range when the camera takes a SET, not a span. */
+	segmentMinutesAllowed: AllowedValuesSchema.optional(),
+	schedule: OnboardScheduleSupportSchema
+});
+/**
+* A partial change. Every field optional.
+*
+* Unlike the other `deviceConfig` caps, a provider here does **NOT**
+* silently ignore a field it cannot support — it refuses, by name,
+* through {@link describeOnboardRefusal}. Silence on a recording setting
+* is the failure D62 exists to prevent: the operator believes the camera
+* is recording the way the form says, and it is not.
+*/
+var RecordingOnboardPatchSchema = zod.z.object({
+	enabled: zod.z.boolean().optional(),
+	overwriteWhenFull: zod.z.boolean().optional(),
+	preRecordSec: zod.z.number().optional(),
+	postRecordSec: zod.z.number().optional(),
+	segmentMinutes: zod.z.number().optional(),
+	/** The complete new window set for the primary track — not a delta. */
+	windows: zod.z.array(RecordWindowSchema).optional()
+});
+var recordingOnboardCapability = {
+	name: "recording-onboard",
+	scope: "device",
+	deviceNative: true,
+	mode: "singleton",
+	deviceTypes: [require_sleep.DeviceType.Camera],
+	deviceConfig: { ui: {
+		kind: "derived-form",
+		builderId: "recording-onboard",
+		tab: "recording"
+	} },
+	methods: {
+		getOptions: require_sleep.method(zod.z.object({ deviceId: zod.z.number() }), RecordingOnboardOptionsSchema),
+		setSettings: require_sleep.method(zod.z.object({
+			deviceId: zod.z.number(),
+			settings: RecordingOnboardPatchSchema
+		}), zod.z.void(), {
+			kind: "mutation",
+			auth: "admin"
+		})
+	},
+	status: {
+		schema: RecordingOnboardStatusSchema,
+		kind: "poll"
+	},
+	runtimeState: RecordingOnboardStatusSchema,
+	/**
+	* Runtime-state durability: **restored** — operator-set camera-side
+	* recording config; mutation-driven, and the storage half is the last
+	* thing the camera said about its own card.
+	*
+	* See `RuntimeStateDurability`. Enforced by
+	* `scripts/check-runtime-state-durability.ts`.
+	*/
+	durability: "restored",
+	/** Clock fields: written, but excluded from the compare that decides
+	*  whether persisting is worth a SQLite commit. */
+	volatileStateFields: ["lastFetchedAt"]
+};
+//#endregion
+//#region src/capabilities/recording-onboard-rules.ts
+/** Minutes in a day. `endMinute === 1440` means "to end of day". */
+var MINUTES_PER_DAY = 1440;
+/** Days in the cap's week, 0 = Monday. */
+var DAYS_PER_WEEK = 7;
+/** Hours per day — the resolution of Reolink's mask. */
+var HOURS_PER_DAY = 24;
+/** Length of a Reolink weekly `valueTable`: 7 days × 24 hours. */
+var WEEKLY_MASK_LENGTH = 168;
+/**
+* Day-of-week names in the cap's index order (0 = Monday), for messages
+* an operator reads and for Hikvision's `<DayOfWeek>` element.
+*/
+var DAY_NAMES = [
+	"Monday",
+	"Tuesday",
+	"Wednesday",
+	"Thursday",
+	"Friday",
+	"Saturday",
+	"Sunday"
+];
+/**
+* Does `patch` ask this camera for something it cannot do?
+*
+* Returns the operator-readable reason, or `null` when every field in
+* the patch is within what `options` says this camera accepts. A
+* provider calls this BEFORE touching the camera and throws the string:
+* refusing is the point, and refusing identically on both vendors is why
+* this is one function.
+*
+* The order of checks is the order an operator would read them: the
+* scalar knobs first, then the schedule, because a schedule complaint is
+* longer and a scalar one is usually the real problem.
+*/
+function describeOnboardRefusal(options, patch) {
+	if (patch.enabled !== void 0 && !options.enabled.writable) return unwritable("the master recording switch", options.enabled.reason);
+	if (patch.overwriteWhenFull !== void 0 && !options.overwriteWhenFull.writable) return unwritable("overwrite-when-full", options.overwriteWhenFull.reason);
+	const preRefusal = refuseNumeric("pre-record seconds", patch.preRecordSec, options.preRecordSec, options.preRecordSecRange, options.preRecordSecAllowed);
+	if (preRefusal) return preRefusal;
+	const postRefusal = refuseNumeric("post-record seconds", patch.postRecordSec, options.postRecordSec, options.postRecordSecRange, options.postRecordSecAllowed);
+	if (postRefusal) return postRefusal;
+	const segmentRefusal = refuseNumeric("segment length (minutes)", patch.segmentMinutes, options.segmentMinutes, options.segmentMinutesRange, options.segmentMinutesAllowed);
+	if (segmentRefusal) return segmentRefusal;
+	if (patch.windows !== void 0) {
+		const scheduleRefusal = refuseSchedule(options, patch.windows);
+		if (scheduleRefusal) return scheduleRefusal;
+	}
+	return null;
+}
+function unwritable(what, reason) {
+	return reason ? `this camera cannot change ${what}: ${reason}` : `this camera cannot change ${what}`;
+}
+function refuseNumeric(what, value, support, range, allowed) {
+	if (value === void 0) return null;
+	if (!support.writable) return unwritable(what, support.reason);
+	if (!Number.isFinite(value)) return `${what} must be a number, got ${String(value)}`;
+	if (allowed) {
+		if (allowed.values.includes(value)) return null;
+		const say = (v) => allowed.sentinel !== void 0 && v === allowed.sentinel.value ? allowed.sentinel.meaning === "no-limit" ? "no limit" : "off" : String(v);
+		return `this camera accepts ${what} only as ${allowed.values.map(say).join(", ")}; ${say(value)} is not one of them`;
+	}
+	if (!range) return null;
+	if (value < range.min || value > range.max) return `this camera accepts ${what} between ${String(range.min)} and ${String(range.max)}; ${String(value)} is outside that`;
+	if (range.step > 0 && (value - range.min) % range.step !== 0) return `this camera accepts ${what} in steps of ${String(range.step)} from ${String(range.min)}; ${String(value)} is not one of them`;
+	return null;
+}
+function refuseSchedule(options, windows) {
+	const schedule = options.schedule;
+	if (!schedule.support.writable) return unwritable("the recording schedule", schedule.support.reason);
+	const allowed = new Set(schedule.triggers);
+	for (const window of windows) {
+		if (!allowed.has(window.trigger)) {
+			const offer = schedule.triggers.length > 0 ? schedule.triggers.join(", ") : "none";
+			return `this camera cannot record on "${window.trigger}"; it records on: ${offer}`;
+		}
+		if (window.endMinute <= window.startMinute) return `a window on ${dayName(window.day)} ends at or before it starts (${String(window.startMinute)} → ${String(window.endMinute)})`;
+		const step = schedule.granularityMinutes;
+		if (step > 1 && (window.startMinute % step !== 0 || window.endMinute % step !== 0)) return `this camera's schedule only moves in ${String(step)}-minute steps; the ${dayName(window.day)} window ${formatMinutes(window.startMinute)}–${formatMinutes(window.endMinute)} is not aligned to them`;
+	}
+	if (!schedule.supportsOverlappingTriggers) {
+		const clash = findOverlapWithDifferentTrigger(windows);
+		if (clash) return `this camera stores one trigger per time range, so "${clash.a.trigger}" and "${clash.b.trigger}" cannot both cover ${dayName(clash.a.day)} ${formatMinutes(Math.max(clash.a.startMinute, clash.b.startMinute))}–${formatMinutes(Math.min(clash.a.endMinute, clash.b.endMinute))}`;
+	}
+	return null;
+}
+function findOverlapWithDifferentTrigger(windows) {
+	for (let i = 0; i < windows.length; i += 1) for (let j = i + 1; j < windows.length; j += 1) {
+		const a = windows[i];
+		const b = windows[j];
+		if (!a || !b) continue;
+		if (a.day !== b.day) continue;
+		if (a.trigger === b.trigger) continue;
+		if (a.startMinute < b.endMinute && b.startMinute < a.endMinute) return {
+			a,
+			b
+		};
+	}
+	return null;
+}
+function dayName(day) {
+	return DAY_NAMES[day] ?? `day ${String(day)}`;
+}
+/** `510` → `08:30`. For messages, not for the wire. */
+function formatMinutes(minute) {
+	const hour = Math.floor(minute / 60);
+	const rest = minute % 60;
+	return `${String(hour).padStart(2, "0")}:${String(rest).padStart(2, "0")}`;
+}
+/**
+* Index of the mask character covering `day` at `hour`.
+*
+* **Layout: day-major, Monday first** — `day * 24 + hour`.
+*
+* This is an ASSUMPTION, and it is recorded as one because the fleet
+* cannot currently confirm it: every `valueTable` on every Reolink
+* measured on 2026-09-22 is uniform (all `1` or all `0`), and a uniform
+* mask reads identically under either layout. To settle it, set a single
+* hour on one day from the Reolink app and re-read `getRecordSchedule`.
+* Until then, a NON-uniform mask is reported as windows under this
+* layout and the day labels may be transposed; a uniform one is exact.
+*/
+function weeklyMaskIndex(day, hour) {
+	return day * 24 + hour;
+}
+/**
+* True when every slot of the mask carries the same value — the case in
+* which {@link weeklyMaskIndex}'s layout assumption cannot be wrong.
+*/
+function weeklyMaskIsUniform(mask) {
+	if (mask.length === 0) return true;
+	const first = mask[0];
+	for (const ch of mask) if (ch !== first) return false;
+	return true;
+}
+/**
+* Expand one trigger's weekly hour mask into windows, merging adjacent
+* set hours into one window per run so a full day is ONE window rather
+* than twenty-four.
+*
+* A mask of the wrong length yields no windows: a truncated table is not
+* a schedule of fewer days, it is an answer we did not understand.
+*/
+function weeklyMaskToWindows(mask, trigger) {
+	if (mask.length !== 168) return [];
+	const out = [];
+	for (let day = 0; day < 7; day += 1) {
+		let runStart = null;
+		for (let hour = 0; hour <= 24; hour += 1) {
+			const set = hour < 24 && mask[weeklyMaskIndex(day, hour)] === "1";
+			if (set && runStart === null) runStart = hour;
+			else if (!set && runStart !== null) {
+				out.push({
+					trigger,
+					day,
+					startMinute: runStart * 60,
+					endMinute: hour * 60
+				});
+				runStart = null;
+			}
+		}
+	}
+	return out;
+}
+/**
+* Collapse this trigger's windows back into a weekly hour mask.
+*
+* Windows for other triggers are ignored — the mask is per trigger. A
+* window that is not hour-aligned is REFUSED upstream by
+* {@link describeOnboardRefusal}; this function rounds nothing, it
+* simply sets every hour the window fully or partly covers, so a caller
+* that skipped the refusal cannot silently lose coverage.
+*/
+function windowsToWeeklyMask(windows, trigger) {
+	const slots = new Array(168).fill("0");
+	for (const window of windows) {
+		if (window.trigger !== trigger) continue;
+		if (window.day < 0 || window.day >= 7) continue;
+		const firstHour = Math.floor(window.startMinute / 60);
+		const lastHour = Math.ceil(window.endMinute / 60);
+		for (let hour = firstHour; hour < lastHour && hour < 24; hour += 1) slots[weeklyMaskIndex(window.day, hour)] = "1";
+	}
+	return slots.join("");
+}
+/**
+* Parse a Hikvision `<TimeOfDay>` into minutes since midnight.
+*
+* The firmware is not self-consistent and both spellings are real, on
+* the same camera in the same block: a start time reads `00:00:00` and
+* the matching end time reads `24:00`. Seconds are accepted and
+* discarded — the cap's resolution is minutes — and `24:00` maps to
+* {@link MINUTES_PER_DAY}, not to 0.
+*
+* Returns null for anything else, which a caller reports as a window it
+* could not read rather than as midnight.
+*/
+function timeOfDayToMinutes(value) {
+	const match = /^(\d{1,2}):(\d{2})(?::(\d{2}))?$/.exec(value.trim());
+	if (!match) return null;
+	const hour = Number(match[1]);
+	const minute = Number(match[2]);
+	if (!Number.isInteger(hour) || !Number.isInteger(minute)) return null;
+	if (minute > 59) return null;
+	const total = hour * 60 + minute;
+	if (total > 1440) return null;
+	return total;
+}
+/**
+* Render minutes back as a Hikvision `TimeOfDay`.
+*
+* Emits the camera's own two spellings: `24:00` for end-of-day, because
+* that is what the firmware writes and `24:00:00` is not observed, and
+* `HH:MM:SS` otherwise.
+*/
+function minutesToTimeOfDay(minute) {
+	if (minute >= 1440) return "24:00";
+	const hour = Math.floor(minute / 60);
+	const rest = minute % 60;
+	return `${String(hour).padStart(2, "0")}:${String(rest).padStart(2, "0")}:00`;
+}
+/** `'Monday'` → 0. Case-insensitive. Null for anything unrecognised. */
+function dayOfWeekToIndex(value) {
+	const needle = value.trim().toLowerCase();
+	const index = DAY_NAMES.findIndex((name) => name.toLowerCase() === needle);
+	return index >= 0 ? index : null;
+}
+/**
+* Which fields of a patch the camera did NOT take verbatim.
+*
+* Measured on a Hikvision I91DN (1436, 2026-09-22): a `PUT` of
+* `PreRecordTimeSeconds: 8` answered `200`, `statusCode 1`, `OK` — and stored
+* **5**. Neither the asked value nor the previous one. The camera declares no
+* allowed set for that field, so there is nothing to refuse against before the
+* wire: `/capabilities` returns a plain value where a constrained field would
+* carry an `opt=` list.
+*
+* So the only honest moment is after the read-back, and re-reading alone is
+* not enough — it makes the difference VISIBLE while leaving it unexplained.
+* A write that reports success for a value the camera never took is the same
+* silent substitution D599 removed from the clip path, wearing a different hat.
+*
+* Compares only the fields the patch actually named: a field nobody asked
+* about cannot have been clamped, and a read-back that could not answer it is
+* `stored: null` rather than a claim.
+*/
+function describeOnboardClamp(patch, landed) {
+	const out = [];
+	for (const [field, asked] of Object.entries(patch)) {
+		if (asked === void 0) continue;
+		if (typeof asked !== "number" && typeof asked !== "boolean" && typeof asked !== "string") continue;
+		const raw = landed === null ? void 0 : landed[field];
+		const stored = typeof raw === "number" || typeof raw === "boolean" || typeof raw === "string" ? raw : null;
+		if (stored !== asked) out.push({
+			field,
+			asked,
+			stored
+		});
+	}
+	return out;
+}
+//#endregion
 //#region src/capabilities/device-status.cap.ts
 /**
 * Generic device-level status snapshot. Auto-registered by `BaseDevice`
@@ -41528,6 +42396,7 @@ var DEVICE_LOCAL_STATE_CAPS = {
 	pressureSensor: pressureSensorCapability,
 	privacyMask: privacyMaskCapability,
 	ptzAutotrack: ptzAutotrackCapability,
+	recordingOnboard: recordingOnboardCapability,
 	recordingSignal: recordingSignalCapability,
 	sceneMonitor: sceneMonitorCapability,
 	scriptRunner: scriptRunnerCapability,
@@ -45976,6 +46845,7 @@ var CAP_NAMES_WITH_STATUS = [
 	"ptz",
 	"ptz-autotrack",
 	"recording",
+	"recording-onboard",
 	"recording-signal",
 	"scene-monitor",
 	"script-runner",
@@ -46039,6 +46909,7 @@ var CAPABILITY_NAMES = {
 	dayNight: "day-night",
 	decoder: "decoder",
 	detectionPipeline: "detection-pipeline",
+	deviceAdminLink: "device-admin-link",
 	deviceAdoption: "device-adoption",
 	deviceDiscovery: "device-discovery",
 	deviceExport: "device-export",
@@ -46113,6 +46984,7 @@ var CAPABILITY_NAMES = {
 	reboot: "reboot",
 	recording: "recording",
 	recordingExport: "recording-export",
+	recordingOnboard: "recording-onboard",
 	recordingSignal: "recording-signal",
 	sceneMonitor: "scene-monitor",
 	scriptRunner: "script-runner",
@@ -46332,6 +47204,10 @@ var CAPABILITY_ROUTER_KEYS = [
 		key: "detectionPipeline",
 		name: "detection-pipeline"
 	},
+	{
+		key: "deviceAdminLink",
+		name: "device-admin-link"
+	},
 	{
 		key: "deviceAdoption",
 		name: "device-adoption"
@@ -46628,6 +47504,10 @@ var CAPABILITY_ROUTER_KEYS = [
 		key: "recordingExport",
 		name: "recording-export"
 	},
+	{
+		key: "recordingOnboard",
+		name: "recording-onboard"
+	},
 	{
 		key: "recordingSignal",
 		name: "recording-signal"
@@ -46843,6 +47723,7 @@ var ALL_CAPABILITY_DEFINITIONS = [
 	dayNightCapability,
 	decoderCapability,
 	detectionPipelineCapability,
+	deviceAdminLinkCapability,
 	deviceAdoptionCapability,
 	deviceDiscoveryCapability,
 	deviceExportCapability,
@@ -46917,6 +47798,7 @@ var ALL_CAPABILITY_DEFINITIONS = [
 	rebootCapability,
 	recordingCapability,
 	recordingExportCapability,
+	recordingOnboardCapability,
 	recordingSignalCapability,
 	sceneMonitorCapability,
 	scriptRunnerCapability,
@@ -48263,6 +49145,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"deviceAdminLink.getAdminLink": {
+		capName: "device-admin-link",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"deviceAdoption.adopt": {
 		capName: "device-adoption",
 		capScope: "system",
@@ -52301,6 +53189,24 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"recordingOnboard.getOptions": {
+		capName: "recording-onboard",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
+	"recordingOnboard.getStatus": {
+		capName: "recording-onboard",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
+	"recordingOnboard.setSettings": {
+		capName: "recording-onboard",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
 	"recordingSignal.getStatus": {
 		capName: "recording-signal",
 		capScope: "device",
@@ -53998,6 +54904,7 @@ var KNOWN_CAP_NAMES = [
 	"day-night",
 	"decoder",
 	"detection-pipeline",
+	"device-admin-link",
 	"device-adoption",
 	"device-discovery",
 	"device-export",
@@ -54072,6 +54979,7 @@ var KNOWN_CAP_NAMES = [
 	"reboot",
 	"recording",
 	"recording-export",
+	"recording-onboard",
 	"recording-signal",
 	"scene-monitor",
 	"script-runner",
@@ -54140,6 +55048,7 @@ var DEVICE_CAP_NAMES = [
 	"cover",
 	"day-night",
 	"detection-pipeline",
+	"device-admin-link",
 	"device-discovery",
 	"device-ops",
 	"device-status",
@@ -54178,6 +55087,7 @@ var DEVICE_CAP_NAMES = [
 	"ptz",
 	"ptz-autotrack",
 	"reboot",
+	"recording-onboard",
 	"recording-signal",
 	"scene-monitor",
 	"script-runner",
@@ -54514,6 +55424,11 @@ var METHOD_DEVICE_SELECTORS = Object.freeze({
 		form: "single",
 		optional: true
 	}],
+	"deviceAdminLink.getAdminLink": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"deviceAdoption.release": [{
 		name: "camDeviceId",
 		form: "single",
@@ -55899,6 +56814,16 @@ var METHOD_DEVICE_SELECTORS = Object.freeze({
 		form: "single",
 		optional: true
 	}],
+	"recordingOnboard.getOptions": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"recordingOnboard.setSettings": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"recordingSignal.getStatus": [{
 		name: "deviceId",
 		form: "single",
@@ -56450,7 +57375,7 @@ function getCapsByProviderKind(kind) {
 //#region src/generated/runtime-state-durability.ts
 /**
 * Per-cap runtime-state policy, projected from every `*.cap.ts` that declares
-* `runtimeState`. 68 caps: 35 `restored`, 33 `session`.
+* `runtimeState`. 69 caps: 36 `restored`, 33 `session`.
 *
 * A cap absent from this map has no runtime-state slice at all. A cap PRESENT
 * with `durability: 'session'` has one and has decided not to keep it.
@@ -56652,6 +57577,10 @@ var RUNTIME_STATE_POLICY = {
 		durability: "session",
 		volatileFields: []
 	},
+	"recording-onboard": {
+		durability: "restored",
+		volatileFields: ["lastFetchedAt"]
+	},
 	"recording-signal": {
 		durability: "session",
 		volatileFields: []
@@ -56776,6 +57705,7 @@ var RESTORED_CAP_NAMES = [
 	"presence",
 	"pressure-sensor",
 	"privacy-mask",
+	"recording-onboard",
 	"smoke",
 	"stream-catalog",
 	"stream-params",
@@ -61645,6 +62575,7 @@ exports.AddonAutoUpdateSchema = AddonAutoUpdateSchema;
 exports.AddonListItemSchema = AddonListItemSchema;
 exports.AddonPageDeclarationSchema = AddonPageDeclarationSchema;
 exports.AddonPageInfoSchema = AddonPageInfoSchema;
+exports.AdminLinkTargetEnum = AdminLinkTargetEnum;
 exports.AdoptionAdoptInputSchema = AdoptInputSchema;
 exports.AdoptionAdoptResultSchema = AdoptResultSchema;
 exports.AdoptionCandidateResultSchema = AdoptionCandidateResultSchema;
@@ -61864,6 +62795,8 @@ exports.CreateUserInputSchema = CreateUserInputSchema;
 exports.CustomActionInputSchema = CustomActionInputSchema;
 exports.CustomModelDescriptorSchema = CustomModelDescriptorSchema;
 exports.DATAPLANE_SECRET_HEADER = require_sleep.DATAPLANE_SECRET_HEADER;
+exports.DAYS_PER_WEEK = DAYS_PER_WEEK;
+exports.DAY_NAMES = DAY_NAMES;
 exports.DECLARED_DEVICE_SWEEP_LIMIT = DECLARED_DEVICE_SWEEP_LIMIT;
 exports.DECLARED_INTEGRATION_FIXED_KEY = DECLARED_INTEGRATION_FIXED_KEY;
 exports.DEFAULT_ADDON_PLACEMENT = DEFAULT_ADDON_PLACEMENT;
@@ -61923,6 +62856,7 @@ exports.DetailCropConventionSchema = DetailCropConventionSchema;
 exports.DetectionCatalogClassMapSchema = DetectionCatalogClassMapSchema;
 exports.DetectionSourceSchema = DetectionSourceSchema;
 exports.DetectionSourcesSchema = DetectionSourcesSchema;
+exports.DeviceAdminLinkSchema = DeviceAdminLinkSchema;
 exports.DeviceCodeSeveritySchema = DeviceCodeSeveritySchema;
 exports.DeviceConfig = DeviceConfig;
 exports.DeviceDiscoveryStatusSchema = DeviceDiscoveryStatusSchema;
@@ -62042,6 +62976,7 @@ exports.HAP_AUDIO_VBV_KBITS = HAP_AUDIO_VBV_KBITS;
 exports.HAP_KEYFRAME_INTERVAL_SEC = HAP_KEYFRAME_INTERVAL_SEC;
 exports.HF_BASE_URL = HF_BASE_URL;
 exports.HF_REPO = HF_REPO;
+exports.HOURS_PER_DAY = HOURS_PER_DAY;
 exports.HWACCEL_OPTIONS = HWACCEL_OPTIONS;
 exports.HealthStatusSchema = HealthStatusSchema;
 exports.HfModelResolutionSchema = HfModelResolutionSchema;
@@ -62161,6 +63096,7 @@ exports.MEDIA_OWNER_TYPES = MEDIA_OWNER_TYPES;
 exports.MEDIA_PRESENCE_OWNER_KINDS = MEDIA_PRESENCE_OWNER_KINDS;
 exports.METHOD_ACCESS_MAP = METHOD_ACCESS_MAP;
 exports.METHOD_DEVICE_SELECTORS = METHOD_DEVICE_SELECTORS;
+exports.MINUTES_PER_DAY = MINUTES_PER_DAY;
 exports.MODEL_FORMATS = MODEL_FORMATS;
 exports.MODEL_PROVIDER_IDS = MODEL_PROVIDER_IDS;
 exports.MOTION_CLOSE_AFTER_MS = MOTION_CLOSE_AFTER_MS;
@@ -62363,6 +63299,11 @@ exports.OVERLAY_LAYERS = OVERLAY_LAYERS;
 exports.OauthIntegrationDescriptorSchema = OauthIntegrationDescriptorSchema;
 exports.ObjectEventSchema = ObjectEventSchema;
 exports.OccupancyBurstRefusalSchema = OccupancyBurstRefusalSchema;
+exports.OnboardFieldSupportSchema = OnboardFieldSupportSchema;
+exports.OnboardRecordTrackSchema = OnboardRecordTrackSchema;
+exports.OnboardScheduleSupportSchema = OnboardScheduleSupportSchema;
+exports.OnboardStorageSchema = OnboardStorageSchema;
+exports.OnboardStorageVolumeSchema = OnboardStorageVolumeSchema;
 exports.OpsLogDomainSchema = OpsLogDomainSchema;
 exports.OpsLogEntrySchema = OpsLogEntrySchema;
 exports.OpsLogOpSchema = OpsLogOpSchema;
@@ -62464,6 +63405,8 @@ exports.ReadinessRegistry = require_sleep.ReadinessRegistry;
 exports.ReadinessTimeoutError = require_sleep.ReadinessTimeoutError;
 exports.RecentTracksPageSchema = RecentTracksPageSchema;
 exports.RecentTracksQueryInput = RecentTracksQueryInput;
+exports.RecordTriggerSchema = RecordTriggerSchema;
+exports.RecordWindowSchema = RecordWindowSchema;
 exports.RecordingAvailabilityForDeviceSchema = RecordingAvailabilityForDeviceSchema;
 exports.RecordingAvailabilitySchema = RecordingAvailabilitySchema;
 exports.RecordingBandAudioSchema = RecordingBandAudioSchema;
@@ -62477,6 +63420,9 @@ exports.RecordingDeviceUsageSchema = RecordingDeviceUsageSchema;
 exports.RecordingLocationUsageSchema = RecordingLocationUsageSchema;
 exports.RecordingManifestSchema = RecordingManifestSchema;
 exports.RecordingObjectTriggerClassSchema = RecordingObjectTriggerClassSchema;
+exports.RecordingOnboardOptionsSchema = RecordingOnboardOptionsSchema;
+exports.RecordingOnboardPatchSchema = RecordingOnboardPatchSchema;
+exports.RecordingOnboardStatusSchema = RecordingOnboardStatusSchema;
 exports.RecordingRangeSchema = RecordingRangeSchema;
 exports.RecordingRebalanceInputSchema = RecordingRebalanceInputSchema;
 exports.RecordingRebalanceMoveSchema = RecordingRebalanceMoveSchema;
@@ -62756,6 +63702,7 @@ exports.VectorUpsertResultSchema = VectorUpsertResultSchema;
 exports.VibrationStatusSchema = VibrationStatusSchema;
 exports.VideoEncodeSchema = VideoEncodeSchema;
 exports.WEBRTC_EGRESS_PROFILE = WEBRTC_EGRESS_PROFILE;
+exports.WEEKLY_MASK_LENGTH = WEEKLY_MASK_LENGTH;
 exports.WELL_KNOWN_TABS = require_sleep.WELL_KNOWN_TABS;
 exports.WELL_KNOWN_TAB_MAP = require_sleep.WELL_KNOWN_TAB_MAP;
 exports.WaterHeaterStatusSchema = WaterHeaterStatusSchema;
@@ -62830,6 +63777,7 @@ exports.brightnessCapability = brightnessCapability;
 exports.brokerCapability = brokerCapability;
 exports.buildAddonRouteProvider = buildAddonRouteProvider;
 exports.buildAudioArgs = require_canonical_hash.buildAudioArgs;
+exports.buildDeviceAdminUrl = buildDeviceAdminUrl;
 exports.buildEventKindDescriptor = buildEventKindDescriptor;
 exports.buildFfmpegArgs = require_canonical_hash.buildFfmpegArgs;
 exports.buildInputArgs = require_canonical_hash.buildInputArgs;
@@ -62898,6 +63846,7 @@ exports.customAction = require_sleep.customAction;
 exports.customModelRegistryCapability = customModelRegistryCapability;
 exports.dataStoreProviderCapability = dataStoreProviderCapability;
 exports.dayNightCapability = dayNightCapability;
+exports.dayOfWeekToIndex = dayOfWeekToIndex;
 exports.declarationOwnerNodeId = declarationOwnerNodeId;
 exports.declareLogChannel = declareLogChannel;
 exports.decodeVectorBase64 = decodeVectorBase64;
@@ -62911,8 +63860,11 @@ exports.deriveDetailCropRect = deriveDetailCropRect;
 exports.deriveRecordingMode = deriveRecordingMode;
 exports.describeCustomActions = require_sleep.describeCustomActions;
 exports.describeModelVariant = describeModelVariant;
+exports.describeOnboardClamp = describeOnboardClamp;
+exports.describeOnboardRefusal = describeOnboardRefusal;
 exports.detectAccessRole = detectAccessRole;
 exports.detectionPipelineCapability = detectionPipelineCapability;
+exports.deviceAdminLinkCapability = deviceAdminLinkCapability;
 exports.deviceAdoptionCapability = deviceAdoptionCapability;
 exports.deviceBackendToFormat = deviceBackendToFormat;
 exports.deviceCustomAction = require_sleep.deviceCustomAction;
@@ -62969,6 +63921,7 @@ exports.foldSnapshotByFunction = foldSnapshotByFunction;
 exports.formatForBackend = formatForBackend;
 exports.formatForRuntime = formatForRuntime;
 exports.formatMediaOwnerKey = formatMediaOwnerKey;
+exports.formatMinutes = formatMinutes;
 exports.formatParkedFor = formatParkedFor;
 exports.gasCapability = gasCapability;
 exports.gbToBytes = gbToBytes;
@@ -63061,6 +64014,7 @@ exports.method = require_sleep.method;
 exports.methodAccessForHttpMethod = methodAccessForHttpMethod;
 exports.metricsProviderCapability = metricsProviderCapability;
 exports.migrateLegacyDeviceSignalConfig = migrateLegacyDeviceSignalConfig;
+exports.minutesToTimeOfDay = minutesToTimeOfDay;
 exports.modeMayRead = modeMayRead;
 exports.modeMayWrite = modeMayWrite;
 exports.modelConvertCapability = modelConvertCapability;
@@ -63094,6 +64048,7 @@ exports.optionalMethod = require_sleep.optionalMethod;
 exports.osdCapability = osdCapability;
 exports.osdManagerCapability = osdManagerCapability;
 exports.overlayClusterStepSettings = overlayClusterStepSettings;
+exports.parseAdminBase = parseAdminBase;
 exports.parseCameraStreamConfig = parseCameraStreamConfig;
 exports.parseExpression = parseExpression;
 exports.parseJsonArray = require_sleep.parseJsonArray;
@@ -63145,6 +64100,7 @@ exports.readinessKey = require_sleep.readinessKey;
 exports.rebootCapability = rebootCapability;
 exports.recordingCapability = recordingCapability;
 exports.recordingExportCapability = recordingExportCapability;
+exports.recordingOnboardCapability = recordingOnboardCapability;
 exports.recordingSignalCapability = recordingSignalCapability;
 exports.rectsToCells = rectsToCells;
 exports.reducePoints = reducePoints;
@@ -63244,6 +64200,7 @@ exports.taskTargetSchema = taskTargetSchema;
 exports.temperatureSensorCapability = temperatureSensorCapability;
 exports.terminalSessionCapability = terminalSessionCapability;
 exports.textToHtml = textToHtml;
+exports.timeOfDayToMinutes = timeOfDayToMinutes;
 exports.toDeviceSummary = toDeviceSummary;
 exports.toExpressionValue = toExpressionValue;
 exports.toNodeId = require_sleep.toNodeId;
@@ -63272,6 +64229,10 @@ exports.waterHeaterCapability = waterHeaterCapability;
 exports.weatherCapability = weatherCapability;
 exports.webrtcClientHintsSchema = webrtcClientHintsSchema;
 exports.webrtcSessionCapability = webrtcSessionCapability;
+exports.weeklyMaskIndex = weeklyMaskIndex;
+exports.weeklyMaskIsUniform = weeklyMaskIsUniform;
+exports.weeklyMaskToWindows = weeklyMaskToWindows;
+exports.windowsToWeeklyMask = windowsToWeeklyMask;
 exports.wiringAddonHealthSchema = wiringAddonHealthSchema;
 exports.wiringHealthSnapshotSchema = wiringHealthSnapshotSchema;
 exports.wiringNodeHealthSchema = wiringNodeHealthSchema;