@camstack/types 1.2.24 → 1.2.25

package/dist/index.js

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_sleep = require("./sleep-CI7DYokZ.js");
+const require_sleep = require("./sleep-BvSjpsfC.js");
 const require_event_category = require("./event-category-BE4PDZ_3.js");
 const require_enums = require("./enums.js");
 const require_err_msg = require("./err-msg-COpsHMw2.js");
@@ -4985,6 +4985,14 @@ var NcMediaPolicySchema = zod.z.object({
 	clipPreRollSec: zod.z.number().int().min(0).max(30).optional(),
 	clipPostRollSec: zod.z.number().int().min(0).max(30).optional(),
 	/**
+	* Playback rate of the attached gif / clip. Absent = 2x.
+	*
+	* A notification clip is GLANCED at on a lock screen, not watched: at real
+	* time an eight-second passage is eight seconds of the recipient's attention
+	* and twice the bytes. 1 is real time for the operator who wants it.
+	*/
+	clipSpeed: zod.z.number().min(1).max(8).optional(),
+	/**
 	* Which stream profile the footage is cut from. Absent = the CHEAPEST
 	* assigned profile: a notification is watched on a phone, so the 4K
 	* rendition would burn CPU to produce a file the client downscales anyway.
@@ -5056,7 +5064,21 @@ var NcRuleInputSchema = zod.z.object({
 	* behaviour, visible to all, read-only in the viewer). Present = personal
 	* rule owned by this userId. Server-stamped; never trusted from a client.
 	*/
-	ownerUserId: zod.z.string().optional()
+	ownerUserId: zod.z.string().optional(),
+	/**
+	* May a non-admin snooze this rule for EVERYONE, not just themselves?
+	*
+	* A snooze is personal by default — it silences the person who set it. This
+	* opts THIS rule into the "the gardener is here all afternoon" case, where
+	* silencing the camera for the whole household is legitimate. It silences
+	* other people, so it is off unless a rule deliberately allows it.
+	*
+	* `.optional()`, deliberately NOT `.default()`: a Zod default does not run on
+	* the addon cap path (three production failures in one day), so absent is
+	* read as `false` by {@link canSetGlobal} in the engine. Admins are not bound
+	* by this flag — see the scope rules on that function.
+	*/
+	snoozeAllowGlobal: zod.z.boolean().optional()
 });
 /**
 * Partial patch for `updateRule` — any subset of the input fields, plus the
@@ -5141,7 +5163,28 @@ var NcConditionDescriptorSchema = zod.z.object({
 	/** Which delivery kinds the condition applies to. */
 	appliesTo: zod.z.array(NcDeliverySchema),
 	phase: zod.z.string(),
-	description: zod.z.string().optional()
+	description: zod.z.string().optional(),
+	/**
+	* The CHOICES for a single-choice widget (`sourceSelect`, `crossingSelect`,
+	* `packagePhase`, …), served with the descriptor.
+	*
+	* Before this the descriptor said which widget to render and not what to put
+	* in it, so every option list lived in three places: this file's enums, the
+	* admin's `NC_*_OPTIONS` and the viewer's `NC_*_VALUES`. That triple mirror
+	* is the drift that emptied the viewer's rule editor on 2026-08-04 — the app
+	* mirrors the cap by hand, so it is only ever as current as its last build.
+	*
+	* With the options on the wire, a condition of an EXISTING `valueType` costs
+	* zero client changes. Clients keep a local fallback for an older hub that
+	* does not send them; absent here is "use your own list", not "no choices".
+	*/
+	options: zod.z.array(zod.z.object({
+		/** Written to the rule verbatim. `''` means the ABSENT state. */
+		value: zod.z.string(),
+		label: zod.z.string(),
+		/** What THIS choice matches — shown one at a time, under the control. */
+		hint: zod.z.string().optional()
+	})).readonly().optional()
 });
 /**
 * The P1 condition surface as data — served by `getConditionCatalog` so
@@ -5235,6 +5278,28 @@ var NC_CONDITION_CATALOG = [
 		group: "zones",
 		label: "Zone crossing",
 		valueType: "crossingSelect",
+		options: [
+			{
+				value: "",
+				label: "Not set — entering",
+				hint: "Entries, and every detection that is not a crossing at all. Exits are excluded. This is what a rule without a crossing condition already does, and choosing it writes nothing to the rule."
+			},
+			{
+				value: "enter",
+				label: "Entered a zone",
+				hint: "The same matches as \"not set\", stated explicitly: entries and non-crossing detections pass, exits do not."
+			},
+			{
+				value: "exit",
+				label: "Left a zone",
+				hint: "ONLY an exit crossing. A detection that is not a crossing fails, so this rule cannot fire on ordinary movement — pair it with the zones the subject must have left. Also matches a tripwire crossed against its drawn direction."
+			},
+			{
+				value: "any",
+				label: "Entered or left",
+				hint: "No direction filter: entries, exits and non-crossing detections alike. This is the only choice that adds exits to what the rule already matched."
+			}
+		],
 		operator: "in",
 		appliesTo: ["immediate"],
 		phase: "P1",
@@ -5315,6 +5380,24 @@ var NC_CONDITION_CATALOG = [
 		group: "scope",
 		label: "Detection source",
 		valueType: "sourceSelect",
+		options: [
+			{
+				value: "any",
+				label: "Any source"
+			},
+			{
+				value: "pipeline",
+				label: "Pipeline"
+			},
+			{
+				value: "onboard",
+				label: "Onboard (camera)"
+			},
+			{
+				value: "sensor",
+				label: "Sensor"
+			}
+		],
 		operator: "in",
 		appliesTo: [
 			"immediate",
@@ -5350,6 +5433,20 @@ var NC_CONDITION_CATALOG = [
 		group: "package",
 		label: "Package phase",
 		valueType: "packagePhase",
+		options: [
+			{
+				value: "delivered",
+				label: "Delivered"
+			},
+			{
+				value: "picked-up",
+				label: "Picked up"
+			},
+			{
+				value: "both",
+				label: "Both"
+			}
+		],
 		operator: "in",
 		appliesTo: ["package-event"],
 		phase: "P1",
@@ -5481,6 +5578,78 @@ var NcHistoryFilterSchema = zod.z.object({
 	until: zod.z.number().optional(),
 	limit: zod.z.number().int().min(1).max(500).default(100)
 });
+/**
+* What a snooze covers. Broader scopes win when several overlap, so one window
+* leaves ONE digest rather than a rule snooze and a whole-feed snooze both
+* summarising the same silence.
+*/
+var NcSnoozeScopeSchema = zod.z.enum([
+	"rule",
+	"device",
+	"all"
+]);
+/** Hard ceiling on a window (24h). A snooze that could not expire would be an
+*  outage the operator asked for once and forgot. */
+var NC_SNOOZE_MAX_MINUTES = 1440;
+/**
+* Client-authored snooze. The server stamps `userId`, `startedAt` and
+* `expiresAt` — a DURATION is sent rather than an instant so a client with a
+* skewed clock cannot author a window that is already over, or never ends.
+*/
+var NcSnoozeInputSchema = zod.z.object({
+	scope: NcSnoozeScopeSchema,
+	/** Required when `scope: 'rule'` — a scoped snooze with no id matches
+	*  NOTHING rather than degrading to "everything". */
+	ruleId: zod.z.string().optional(),
+	/** Required when `scope: 'device'`. */
+	deviceId: zod.z.number().int().optional(),
+	durationMinutes: zod.z.number().int().min(1).max(NC_SNOOZE_MAX_MINUTES),
+	/**
+	* Silence this for EVERY recipient, not just the caller. Permission is
+	* checked server-side (the rule's `snoozeAllowGlobal`, or admin for the
+	* broader scopes). Absent = personal.
+	*/
+	global: zod.z.boolean().optional(),
+	/**
+	* Deliver a summary of what was suppressed when the window ends. Absent =
+	* ON: someone silencing a nuisance camera wants it off, someone silencing a
+	* SECURITY camera wants to know what they missed, and choosing "off" for
+	* everybody is how a snooze becomes an outage. Resolved to a concrete
+	* boolean by the server at create time — never left to a Zod default, which
+	* does not run on the addon cap path.
+	*/
+	summary: zod.z.boolean().optional()
+});
+/** A persisted snooze window. */
+var NcSnoozeSchema = zod.z.object({
+	id: zod.z.string(),
+	/** Who set it. Also who it silences, unless `global`. */
+	userId: zod.z.string(),
+	scope: NcSnoozeScopeSchema,
+	ruleId: zod.z.string().optional(),
+	deviceId: zod.z.number().int().optional(),
+	startedAt: zod.z.number(),
+	/** Exclusive: at exactly this instant the snooze is over. Expiry is a
+	*  COMPARISON, not a job — no sweeper can leave the operator silenced. */
+	expiresAt: zod.z.number(),
+	global: zod.z.boolean(),
+	summary: zod.z.boolean(),
+	/** When the end-of-window digest went out. Absent = not sent (yet, or the
+	*  window has not closed, or `summary` is false). */
+	digestSentAt: zod.z.number().optional()
+});
+/** One line of an end-of-window digest: what one rule hid on one camera. */
+var NcSnoozeSuppressedSchema = zod.z.object({
+	snoozeId: zod.z.string(),
+	targetId: zod.z.string(),
+	ruleId: zod.z.string(),
+	ruleName: zod.z.string(),
+	deviceId: zod.z.number().int(),
+	/** How many notifications this snooze hid for that pair. */
+	count: zod.z.number().int(),
+	firstAt: zod.z.number(),
+	lastAt: zod.z.number()
+});
 var notificationRulesCapability = {
 	name: "notification-rules",
 	scope: "system",
@@ -5547,7 +5716,36 @@ var notificationRulesCapability = {
 		* P1 (no user dimension); the P2 viewer History screen adds per-caller
 		* scoping on the same method.
 		*/
-		getHistory: require_sleep.method(zod.z.object({ filter: NcHistoryFilterSchema.default({ limit: 100 }) }), zod.z.object({ entries: zod.z.array(NcHistoryEntrySchema) }), { auth: "admin" })
+		getHistory: require_sleep.method(zod.z.object({ filter: NcHistoryFilterSchema.default({ limit: 100 }) }), zod.z.object({ entries: zod.z.array(NcHistoryEntrySchema) }), { auth: "admin" }),
+		/**
+		* Snooze windows currently in effect, plus any whose digest has not yet
+		* gone out. `caller: 'required'`: a user sees their OWN windows and the
+		* global ones that silence them, never another person's private silence.
+		* An admin sees every window — a household-wide silence is exactly the
+		* thing an operator has to be able to find and cancel.
+		*/
+		listSnoozes: require_sleep.method(zod.z.object({}), zod.z.object({ snoozes: zod.z.array(NcSnoozeSchema) }), { caller: "required" }),
+		/**
+		* Open a window. `userId` is stamped from the caller; a GLOBAL window is
+		* permission-checked server-side (the rule's `snoozeAllowGlobal` for a
+		* rule-scoped one, admin for a camera or the whole feed) — a client asking
+		* for one it may not have is rejected, never silently downgraded, because
+		* a snooze the operator believes is in effect and is not is the same
+		* failure as one they cannot end.
+		*/
+		createSnooze: require_sleep.method(zod.z.object({ snooze: NcSnoozeInputSchema }), zod.z.object({ snooze: NcSnoozeSchema }), {
+			kind: "mutation",
+			caller: "required"
+		}),
+		/**
+		* End a window NOW. The digest still goes out (what was hidden while it
+		* was open is still what the operator missed); only the silence stops.
+		* A user may cancel their own; an admin may cancel any.
+		*/
+		cancelSnooze: require_sleep.method(zod.z.object({ snoozeId: zod.z.string() }), zod.z.object({ success: zod.z.literal(true) }), {
+			kind: "mutation",
+			caller: "required"
+		})
 	}
 };
 //#endregion
@@ -6656,7 +6854,15 @@ var streamBrokerCapability = {
 			format: zod.z.enum(["gif", "mp4"]).default("gif"),
 			maxWidth: zod.z.number().int().min(120).max(1920).default(480),
 			/** GIF only — MP4 keeps the source cadence. */
-			fps: zod.z.number().int().min(1).max(15).default(5)
+			fps: zod.z.number().int().min(1).max(15).default(5),
+			/**
+			* Playback rate. A notification clip is GLANCED at on a lock screen,
+			* not watched, so 2x is the default: the recipient sees the whole
+			* passage in half the time and the GIF is half the bytes. `1` is real
+			* time. Applies to MP4 as well — the operator set a speed, not a GIF
+			* speed.
+			*/
+			speed: zod.z.number().min(1).max(8).default(2)
 		}), zod.z.object({
 			base64: zod.z.string(),
 			mime: zod.z.string(),
@@ -14796,17 +15002,6 @@ function createSystemProxy(api) {
 			deleteTarget: (input) => dispatch("notificationOutput", "deleteTarget", "mutation", input),
 			setTargetEnabled: (input) => dispatch("notificationOutput", "setTargetEnabled", "mutation", input)
 		},
-		notificationRules: {
-			listRules: (input) => dispatch("notificationRules", "listRules", "query", input),
-			getRule: (input) => dispatch("notificationRules", "getRule", "query", input),
-			createRule: (input) => dispatch("notificationRules", "createRule", "mutation", input),
-			updateRule: (input) => dispatch("notificationRules", "updateRule", "mutation", input),
-			deleteRule: (input) => dispatch("notificationRules", "deleteRule", "mutation", input),
-			setRuleEnabled: (input) => dispatch("notificationRules", "setRuleEnabled", "mutation", input),
-			testRule: (input) => dispatch("notificationRules", "testRule", "mutation", input),
-			getConditionCatalog: (input) => dispatch("notificationRules", "getConditionCatalog", "query", input),
-			getHistory: (input) => dispatch("notificationRules", "getHistory", "query", input)
-		},
 		pipelineExecutor: {
 			getAvailableEngines: (input) => dispatch("pipelineExecutor", "getAvailableEngines", "query", input),
 			getSelectedEngine: (input) => dispatch("pipelineExecutor", "getSelectedEngine", "query", input),
@@ -30706,12 +30901,24 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"notificationRules.cancelSnooze": {
+		capName: "notification-rules",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"notificationRules.createRule": {
 		capName: "notification-rules",
 		capScope: "system",
 		addonId: null,
 		access: "create"
 	},
+	"notificationRules.createSnooze": {
+		capName: "notification-rules",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"notificationRules.deleteRule": {
 		capName: "notification-rules",
 		capScope: "system",
@@ -30742,6 +30949,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"notificationRules.listSnoozes": {
+		capName: "notification-rules",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"notificationRules.setRuleEnabled": {
 		capName: "notification-rules",
 		capScope: "system",
@@ -34270,6 +34483,7 @@ exports.NC_CONDITION_CATALOG = NC_CONDITION_CATALOG;
 exports.NC_HISTORY_LIMIT_DEFAULT = NC_HISTORY_LIMIT_DEFAULT;
 exports.NC_HISTORY_LIMIT_MAX = NC_HISTORY_LIMIT_MAX;
 exports.NC_MAX_PER_TRACK_IMMEDIATE = NC_MAX_PER_TRACK_IMMEDIATE;
+exports.NC_SNOOZE_MAX_MINUTES = NC_SNOOZE_MAX_MINUTES;
 exports.NC_TAXONOMY = NC_TAXONOMY;
 exports.NativeCropBboxSchema = NativeCropBboxSchema;
 exports.NativeCropRefSchema = NativeCropRefSchema;
@@ -34297,6 +34511,10 @@ exports.NcRuleSchema = NcRuleSchema;
 exports.NcRuleTargetSchema = NcRuleTargetSchema;
 exports.NcScheduleSchema = NcScheduleSchema;
 exports.NcScheduleWindowSchema = NcScheduleWindowSchema;
+exports.NcSnoozeInputSchema = NcSnoozeInputSchema;
+exports.NcSnoozeSchema = NcSnoozeSchema;
+exports.NcSnoozeScopeSchema = NcSnoozeScopeSchema;
+exports.NcSnoozeSuppressedSchema = NcSnoozeSuppressedSchema;
 exports.NcTaxonomyEntrySchema = NcTaxonomyEntrySchema;
 exports.NcTaxonomySchema = NcTaxonomySchema;
 exports.NcTestResultSchema = NcTestResultSchema;