@camstack/addon-notifiers 1.2.602 → 1.2.603
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/addon.js +251 -44
- package/dist/addon.mjs +251 -44
- package/package.json +1 -1
package/dist/addon.js
CHANGED
|
@@ -29,7 +29,7 @@ let node_fs = require("node:fs");
|
|
|
29
29
|
let node_path = require("node:path");
|
|
30
30
|
node_path = __toESM(node_path);
|
|
31
31
|
let node_url = require("node:url");
|
|
32
|
-
//#region ../types/dist/event-category-
|
|
32
|
+
//#region ../types/dist/event-category-DOl51-Ij.mjs
|
|
33
33
|
var EventCategory = /* @__PURE__ */ function(EventCategory) {
|
|
34
34
|
EventCategory["SystemBoot"] = "system.boot";
|
|
35
35
|
EventCategory["SystemAddonsReady"] = "system.addons-ready";
|
|
@@ -108,9 +108,18 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
|
|
|
108
108
|
/**
|
|
109
109
|
* The node's one-shot runner boot check (D877): planned runners against the
|
|
110
110
|
* process service, `degraded` when any is failed, refused or missing. The
|
|
111
|
-
* alert centre turns it into one
|
|
111
|
+
* alert centre turns it into one critical alert.
|
|
112
112
|
*/
|
|
113
113
|
EventCategory["SystemRunnerCheck"] = "system.runner-check";
|
|
114
|
+
/**
|
|
115
|
+
* An alert EPISODE opened or closed, emitted by the alert centre for alerts
|
|
116
|
+
* of severity `critical` or `error` (`AlertEpisodePayload`). The alert
|
|
117
|
+
* centre sends no notification of its own: Notification Center turns this
|
|
118
|
+
* into the `alert-critical` / `alert-error` / `alert-critical-resolved`
|
|
119
|
+
* system-event kinds, and reconciles from the alerts store because a bus
|
|
120
|
+
* event may be dropped (D8, D11).
|
|
121
|
+
*/
|
|
122
|
+
EventCategory["AlertEpisode"] = "alert.episode";
|
|
114
123
|
EventCategory["AddonError"] = "addon.error";
|
|
115
124
|
EventCategory["AddonPageReady"] = "addon.page-ready";
|
|
116
125
|
EventCategory["AddonWidgetReady"] = "addon.widget-ready";
|
|
@@ -5568,7 +5577,7 @@ var ZodIssueCode = {
|
|
|
5568
5577
|
var ZodFirstPartyTypeKind;
|
|
5569
5578
|
ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
|
|
5570
5579
|
//#endregion
|
|
5571
|
-
//#region ../types/dist/sleep-
|
|
5580
|
+
//#region ../types/dist/sleep-BxjU_fJM.mjs
|
|
5572
5581
|
/**
|
|
5573
5582
|
* The audio chunk plane's byte format, and the ONE expansion from a coded
|
|
5574
5583
|
* window to float samples (D455).
|
|
@@ -13636,7 +13645,14 @@ var AlertSeveritySchema = _enum([
|
|
|
13636
13645
|
]);
|
|
13637
13646
|
var AlertActionSchema = object({
|
|
13638
13647
|
label: string(),
|
|
13639
|
-
href: string().optional()
|
|
13648
|
+
href: string().optional(),
|
|
13649
|
+
/**
|
|
13650
|
+
* How `href` is followed. Absent / `app`: an admin-ui route (client-side).
|
|
13651
|
+
* `server`: a route the HUB serves (an addon HTTP route such as an OAuth
|
|
13652
|
+
* start) — the browser must leave the SPA with a full navigation, because
|
|
13653
|
+
* the SPA has no such route and would bounce to the home page.
|
|
13654
|
+
*/
|
|
13655
|
+
navigation: _enum(["app", "server"]).optional()
|
|
13640
13656
|
});
|
|
13641
13657
|
var AlertStatusSchema = _enum([
|
|
13642
13658
|
"active",
|
|
@@ -42034,6 +42050,9 @@ var NcSystemEventKindSchema = _enum([
|
|
|
42034
42050
|
"server-updated",
|
|
42035
42051
|
"export-completed",
|
|
42036
42052
|
"backup-completed",
|
|
42053
|
+
"alert-critical",
|
|
42054
|
+
"alert-error",
|
|
42055
|
+
"alert-critical-resolved",
|
|
42037
42056
|
"camera-online",
|
|
42038
42057
|
"camera-offline",
|
|
42039
42058
|
"camera-disabled",
|
|
@@ -51066,7 +51085,10 @@ method(StorageMigrationInputSchema, StorageMigrationPlanSchema, { auth: "admin"
|
|
|
51066
51085
|
}), method(object({ jobId: string().optional() }), StorageMigrationJobSchema.nullable(), { auth: "admin" }), method(object({ jobId: string() }), object({ cancelled: boolean() }), {
|
|
51067
51086
|
kind: "mutation",
|
|
51068
51087
|
auth: "admin"
|
|
51069
|
-
}), method(object({}), array(StorageMigrationMoverSchema).readonly(), { auth: "admin" }), method(object({
|
|
51088
|
+
}), method(object({}), array(StorageMigrationMoverSchema).readonly(), { auth: "admin" }), method(object({ locationIds: array(string()).readonly() }), object({
|
|
51089
|
+
clear: boolean(),
|
|
51090
|
+
repointLocationId: string().optional()
|
|
51091
|
+
}), { auth: "admin" }), method(object({}), array(StorageMigrationResidueSchema).readonly(), { auth: "admin" }), method(StorageMigrationDrainInputSchema, object({ jobId: string() }), {
|
|
51070
51092
|
kind: "mutation",
|
|
51071
51093
|
auth: "admin"
|
|
51072
51094
|
}), method(StorageCleanupInputSchema, object({ jobId: string() }), {
|
|
@@ -54501,6 +54523,11 @@ object({
|
|
|
54501
54523
|
*
|
|
54502
54524
|
* `kind: 'poll'` — cloud REST APIs typically have no push channel; the
|
|
54503
54525
|
* provider refreshes the slice on an interval and eagerly after commands.
|
|
54526
|
+
*
|
|
54527
|
+
* UNKNOWN IS NOT OFF. Every field the appliance reports separately is
|
|
54528
|
+
* nullable: `null` means "not known right now" (the appliance has not said,
|
|
54529
|
+
* the link is down, or the description does not carry it) and is never
|
|
54530
|
+
* rendered or exported as `false` / `0`. `availability` says why.
|
|
54504
54531
|
*/
|
|
54505
54532
|
var DishwasherStateSchema = _enum([
|
|
54506
54533
|
"idle",
|
|
@@ -54510,112 +54537,227 @@ var DishwasherStateSchema = _enum([
|
|
|
54510
54537
|
"error",
|
|
54511
54538
|
"unavailable"
|
|
54512
54539
|
]);
|
|
54540
|
+
/**
|
|
54541
|
+
* The appliance's own operation state, uncollapsed. `state` above is the coarse
|
|
54542
|
+
* view for compact surfaces; this is what the appliance said.
|
|
54543
|
+
*/
|
|
54544
|
+
var DishwasherOperationStateSchema = _enum([
|
|
54545
|
+
"Inactive",
|
|
54546
|
+
"Ready",
|
|
54547
|
+
"DelayedStart",
|
|
54548
|
+
"Run",
|
|
54549
|
+
"Pause",
|
|
54550
|
+
"ActionRequired",
|
|
54551
|
+
"Finished",
|
|
54552
|
+
"Error",
|
|
54553
|
+
"Aborting"
|
|
54554
|
+
]);
|
|
54555
|
+
/**
|
|
54556
|
+
* Why fields may be `null`:
|
|
54557
|
+
* - `available` — the link is up and the description is loaded;
|
|
54558
|
+
* - `offline` — the local link is down (values are unknown, not last-known);
|
|
54559
|
+
* - `description-missing` — the link is up but the appliance's description could not
|
|
54560
|
+
* be loaded, so its values cannot be decoded.
|
|
54561
|
+
*/
|
|
54562
|
+
var DishwasherAvailabilitySchema = _enum([
|
|
54563
|
+
"available",
|
|
54564
|
+
"offline",
|
|
54565
|
+
"description-missing"
|
|
54566
|
+
]);
|
|
54513
54567
|
var DishwasherConsumableLevelSchema = _enum([
|
|
54514
54568
|
"ok",
|
|
54515
54569
|
"low",
|
|
54516
54570
|
"empty"
|
|
54517
54571
|
]);
|
|
54518
54572
|
object({
|
|
54573
|
+
availability: DishwasherAvailabilitySchema,
|
|
54574
|
+
/** Coarse state for compact surfaces; `unavailable` whenever the appliance state is not known. */
|
|
54519
54575
|
state: DishwasherStateSchema,
|
|
54520
|
-
/**
|
|
54576
|
+
/** The appliance's operation state as reported; null when not known. */
|
|
54577
|
+
operationState: DishwasherOperationStateSchema.nullable(),
|
|
54578
|
+
/** Feature key of the ACTIVE (running) program, or null when none runs / not known. */
|
|
54521
54579
|
program: string().nullable(),
|
|
54522
|
-
/**
|
|
54580
|
+
/** Feature key of the SELECTED program (what Start would run), or null when none / not known. */
|
|
54581
|
+
selectedProgram: string().nullable(),
|
|
54582
|
+
/** Feature keys of the programs the appliance currently offers — drives the UI selector. */
|
|
54523
54583
|
availablePrograms: array(string()),
|
|
54524
|
-
/**
|
|
54525
|
-
|
|
54584
|
+
/** Seconds remaining on the active cycle, or null when not running / not known. */
|
|
54585
|
+
remainingSeconds: number().int().nonnegative().nullable(),
|
|
54586
|
+
/** Seconds the delayed start is set to (time until the cycle starts), or null. */
|
|
54587
|
+
delayedStartSeconds: number().int().nonnegative().nullable(),
|
|
54526
54588
|
/** Cycle completion 0..100, or null when not applicable. */
|
|
54527
54589
|
progressPercent: number().min(0).max(100).nullable(),
|
|
54528
|
-
/** True when the door is reported open. */
|
|
54529
|
-
doorOpen: boolean(),
|
|
54530
|
-
/** True when
|
|
54531
|
-
|
|
54532
|
-
/**
|
|
54533
|
-
|
|
54590
|
+
/** True when the door is reported open; null when the door state is not known. */
|
|
54591
|
+
doorOpen: boolean().nullable(),
|
|
54592
|
+
/** True when the door is latched (locked) during a cycle; null when not reported. */
|
|
54593
|
+
doorLocked: boolean().nullable(),
|
|
54594
|
+
/** True when remote start is allowed (door closed, power on, etc.); null when not known. */
|
|
54595
|
+
remoteStartAllowed: boolean().nullable(),
|
|
54596
|
+
/** True when the appliance accepts remote control now; null when not known. */
|
|
54597
|
+
remoteControlActive: boolean().nullable(),
|
|
54598
|
+
/** True while somebody operates the appliance at its panel; null when not reported. */
|
|
54599
|
+
localControlActive: boolean().nullable(),
|
|
54600
|
+
/** Main power / switched-on state; null when not known. */
|
|
54601
|
+
powerOn: boolean().nullable(),
|
|
54602
|
+
/** The raw power state (`On`, `Off`, `Standby`, …); null when not known. */
|
|
54603
|
+
powerState: string().nullable(),
|
|
54534
54604
|
saltLevel: DishwasherConsumableLevelSchema.nullable(),
|
|
54535
54605
|
rinseAidLevel: DishwasherConsumableLevelSchema.nullable(),
|
|
54536
|
-
|
|
54537
|
-
|
|
54606
|
+
/** Option states: null when the appliance does not expose the option or has not said. */
|
|
54607
|
+
halfLoad: boolean().nullable(),
|
|
54608
|
+
hygienePlus: boolean().nullable(),
|
|
54538
54609
|
/** Extra dry option when the appliance exposes it. */
|
|
54539
|
-
extraDry: boolean(),
|
|
54610
|
+
extraDry: boolean().nullable(),
|
|
54540
54611
|
/** Intensive zone (lower basket) when the appliance exposes it. */
|
|
54541
|
-
intensiveZone: boolean(),
|
|
54612
|
+
intensiveZone: boolean().nullable(),
|
|
54542
54613
|
/** VarioSpeed / VarioSpeed+ when the appliance exposes it. */
|
|
54543
|
-
varioSpeedPlus: boolean(),
|
|
54544
|
-
/** Child lock (controls disabled on the appliance). */
|
|
54545
|
-
childLock: boolean(),
|
|
54614
|
+
varioSpeedPlus: boolean().nullable(),
|
|
54615
|
+
/** Child lock (controls disabled on the appliance); null when not known. */
|
|
54616
|
+
childLock: boolean().nullable(),
|
|
54617
|
+
/** Feature keys of the events currently raised (salt low, rinse aid low, program finished, …). */
|
|
54618
|
+
activeEvents: array(string()),
|
|
54619
|
+
/** Numeric error code when the appliance reports one; null otherwise. */
|
|
54546
54620
|
errorCode: number().nullable(),
|
|
54621
|
+
/** Name of the raised alert-level event while the appliance is in error; null otherwise. */
|
|
54547
54622
|
errorLabel: string().nullable(),
|
|
54623
|
+
/** Ms epoch of the last value received from the appliance; 0 = never. */
|
|
54548
54624
|
lastFetchedAt: number()
|
|
54549
54625
|
});
|
|
54550
|
-
|
|
54626
|
+
var DeviceIdSchema = number().int().nonnegative();
|
|
54627
|
+
/** A value a program option or setting can take. */
|
|
54628
|
+
var DishwasherValueSchema = union([
|
|
54629
|
+
boolean(),
|
|
54630
|
+
string(),
|
|
54631
|
+
number()
|
|
54632
|
+
]);
|
|
54633
|
+
var DishwasherAccessSchema = _enum([
|
|
54634
|
+
"none",
|
|
54635
|
+
"read",
|
|
54636
|
+
"readWrite",
|
|
54637
|
+
"writeOnly",
|
|
54638
|
+
"readStatic"
|
|
54639
|
+
]);
|
|
54640
|
+
/**
|
|
54641
|
+
* One option or setting the appliance declares, with the constraints its description
|
|
54642
|
+
* gives. A `readWrite` descriptor that is `available` is what `setOption` accepts.
|
|
54643
|
+
*/
|
|
54644
|
+
var DishwasherOptionDescriptorSchema = object({
|
|
54645
|
+
/** Feature key (`Dishcare.Dishwasher.Option.ExtraDry`). */
|
|
54646
|
+
key: string(),
|
|
54647
|
+
/** Last segment of the key, for display. */
|
|
54648
|
+
name: string(),
|
|
54649
|
+
type: _enum([
|
|
54650
|
+
"boolean",
|
|
54651
|
+
"number",
|
|
54652
|
+
"enum",
|
|
54653
|
+
"string"
|
|
54654
|
+
]),
|
|
54655
|
+
access: DishwasherAccessSchema,
|
|
54656
|
+
/** The appliance reports this entity as currently available. */
|
|
54657
|
+
available: boolean(),
|
|
54658
|
+
/** Unit the description declares for a number; null when it declares none. */
|
|
54659
|
+
unit: string().nullable(),
|
|
54660
|
+
min: number().nullable(),
|
|
54661
|
+
max: number().nullable(),
|
|
54662
|
+
step: number().nullable(),
|
|
54663
|
+
/** Allowed members of an enum; null for other types. */
|
|
54664
|
+
enumValues: array(string()).nullable(),
|
|
54665
|
+
defaultValue: DishwasherValueSchema.nullable()
|
|
54666
|
+
});
|
|
54667
|
+
var DishwasherProgramSchema = object({
|
|
54668
|
+
/** Feature key (`Dishcare.Dishwasher.Program.Eco50`) — what `setProgram` / `start` take. */
|
|
54669
|
+
key: string(),
|
|
54670
|
+
name: string(),
|
|
54671
|
+
/** The appliance currently offers this program. */
|
|
54672
|
+
available: boolean(),
|
|
54673
|
+
/** The options this program lists, with the program-level access / availability / default. */
|
|
54674
|
+
options: array(DishwasherOptionDescriptorSchema)
|
|
54675
|
+
});
|
|
54676
|
+
var DishwasherOptionsSchema = object({
|
|
54677
|
+
availability: DishwasherAvailabilitySchema,
|
|
54678
|
+
/** What the appliance can be told to do, from the commands its description declares. */
|
|
54679
|
+
supportsStart: boolean(),
|
|
54680
|
+
supportsPause: boolean(),
|
|
54681
|
+
supportsResume: boolean(),
|
|
54682
|
+
supportsStop: boolean(),
|
|
54683
|
+
supportsPower: boolean(),
|
|
54684
|
+
/** Every program the description lists, with its options. */
|
|
54685
|
+
programs: array(DishwasherProgramSchema),
|
|
54686
|
+
/** Every option and setting entity the description lists (programs reference these by key). */
|
|
54687
|
+
options: array(DishwasherOptionDescriptorSchema)
|
|
54688
|
+
});
|
|
54689
|
+
DeviceType.Dishwasher, method(object({
|
|
54690
|
+
deviceId: DeviceIdSchema,
|
|
54691
|
+
program: string().min(1).optional(),
|
|
54692
|
+
options: record(string(), DishwasherValueSchema).optional()
|
|
54693
|
+
}), _void(), {
|
|
54551
54694
|
kind: "mutation",
|
|
54552
54695
|
auth: "protected"
|
|
54553
|
-
}), method(object({ deviceId:
|
|
54696
|
+
}), method(object({ deviceId: DeviceIdSchema }), _void(), {
|
|
54554
54697
|
kind: "mutation",
|
|
54555
54698
|
auth: "protected"
|
|
54556
|
-
}), method(object({ deviceId:
|
|
54699
|
+
}), method(object({ deviceId: DeviceIdSchema }), _void(), {
|
|
54700
|
+
kind: "mutation",
|
|
54701
|
+
auth: "protected"
|
|
54702
|
+
}), method(object({ deviceId: DeviceIdSchema }), _void(), {
|
|
54557
54703
|
kind: "mutation",
|
|
54558
54704
|
auth: "protected"
|
|
54559
54705
|
}), method(object({
|
|
54560
|
-
deviceId:
|
|
54706
|
+
deviceId: DeviceIdSchema,
|
|
54561
54707
|
program: string().min(1)
|
|
54562
54708
|
}), _void(), {
|
|
54563
54709
|
kind: "mutation",
|
|
54564
54710
|
auth: "protected"
|
|
54565
54711
|
}), method(object({
|
|
54566
|
-
deviceId:
|
|
54712
|
+
deviceId: DeviceIdSchema,
|
|
54567
54713
|
on: boolean()
|
|
54568
54714
|
}), _void(), {
|
|
54569
54715
|
kind: "mutation",
|
|
54570
54716
|
auth: "protected"
|
|
54571
54717
|
}), method(object({
|
|
54572
|
-
deviceId:
|
|
54718
|
+
deviceId: DeviceIdSchema,
|
|
54573
54719
|
on: boolean()
|
|
54574
54720
|
}), _void(), {
|
|
54575
54721
|
kind: "mutation",
|
|
54576
54722
|
auth: "protected"
|
|
54577
54723
|
}), method(object({
|
|
54578
|
-
deviceId:
|
|
54724
|
+
deviceId: DeviceIdSchema,
|
|
54579
54725
|
on: boolean()
|
|
54580
54726
|
}), _void(), {
|
|
54581
54727
|
kind: "mutation",
|
|
54582
54728
|
auth: "protected"
|
|
54583
54729
|
}), method(object({
|
|
54584
|
-
deviceId:
|
|
54730
|
+
deviceId: DeviceIdSchema,
|
|
54585
54731
|
on: boolean()
|
|
54586
54732
|
}), _void(), {
|
|
54587
54733
|
kind: "mutation",
|
|
54588
54734
|
auth: "protected"
|
|
54589
54735
|
}), method(object({
|
|
54590
|
-
deviceId:
|
|
54736
|
+
deviceId: DeviceIdSchema,
|
|
54591
54737
|
on: boolean()
|
|
54592
54738
|
}), _void(), {
|
|
54593
54739
|
kind: "mutation",
|
|
54594
54740
|
auth: "protected"
|
|
54595
54741
|
}), method(object({
|
|
54596
|
-
deviceId:
|
|
54742
|
+
deviceId: DeviceIdSchema,
|
|
54597
54743
|
on: boolean()
|
|
54598
54744
|
}), _void(), {
|
|
54599
54745
|
kind: "mutation",
|
|
54600
54746
|
auth: "protected"
|
|
54601
54747
|
}), method(object({
|
|
54602
|
-
deviceId:
|
|
54748
|
+
deviceId: DeviceIdSchema,
|
|
54603
54749
|
on: boolean()
|
|
54604
54750
|
}), _void(), {
|
|
54605
54751
|
kind: "mutation",
|
|
54606
54752
|
auth: "protected"
|
|
54607
54753
|
}), method(object({
|
|
54608
|
-
deviceId:
|
|
54754
|
+
deviceId: DeviceIdSchema,
|
|
54609
54755
|
key: string().min(1),
|
|
54610
|
-
value:
|
|
54611
|
-
boolean(),
|
|
54612
|
-
string(),
|
|
54613
|
-
number()
|
|
54614
|
-
])
|
|
54756
|
+
value: DishwasherValueSchema
|
|
54615
54757
|
}), _void(), {
|
|
54616
54758
|
kind: "mutation",
|
|
54617
54759
|
auth: "protected"
|
|
54618
|
-
});
|
|
54760
|
+
}), method(object({ deviceId: DeviceIdSchema }), DishwasherOptionsSchema, { auth: "protected" });
|
|
54619
54761
|
object({
|
|
54620
54762
|
/** Ms epoch of the last press. null = never observed since this provider started. */
|
|
54621
54763
|
lastPressedAt: number().nullable(),
|
|
@@ -64675,6 +64817,12 @@ Object.freeze({
|
|
|
64675
64817
|
addonId: null,
|
|
64676
64818
|
access: "view"
|
|
64677
64819
|
},
|
|
64820
|
+
"dishwasher.getOptions": {
|
|
64821
|
+
capName: "dishwasher",
|
|
64822
|
+
capScope: "device",
|
|
64823
|
+
addonId: null,
|
|
64824
|
+
access: "view"
|
|
64825
|
+
},
|
|
64678
64826
|
"dishwasher.getStatus": {
|
|
64679
64827
|
capName: "dishwasher",
|
|
64680
64828
|
capScope: "device",
|
|
@@ -64687,6 +64835,12 @@ Object.freeze({
|
|
|
64687
64835
|
addonId: null,
|
|
64688
64836
|
access: "create"
|
|
64689
64837
|
},
|
|
64838
|
+
"dishwasher.resume": {
|
|
64839
|
+
capName: "dishwasher",
|
|
64840
|
+
capScope: "device",
|
|
64841
|
+
addonId: null,
|
|
64842
|
+
access: "create"
|
|
64843
|
+
},
|
|
64690
64844
|
"dishwasher.setChildLock": {
|
|
64691
64845
|
capName: "dishwasher",
|
|
64692
64846
|
capScope: "device",
|
|
@@ -69187,6 +69341,12 @@ Object.freeze({
|
|
|
69187
69341
|
addonId: null,
|
|
69188
69342
|
access: "view"
|
|
69189
69343
|
},
|
|
69344
|
+
"storageMigration.moverClearance": {
|
|
69345
|
+
capName: "storage-migration",
|
|
69346
|
+
capScope: "system",
|
|
69347
|
+
addonId: null,
|
|
69348
|
+
access: "view"
|
|
69349
|
+
},
|
|
69190
69350
|
"storageMigration.movers": {
|
|
69191
69351
|
capName: "storage-migration",
|
|
69192
69352
|
capScope: "system",
|
|
@@ -71380,6 +71540,11 @@ Object.freeze({
|
|
|
71380
71540
|
form: "single",
|
|
71381
71541
|
optional: false
|
|
71382
71542
|
}],
|
|
71543
|
+
"dishwasher.getOptions": [{
|
|
71544
|
+
name: "deviceId",
|
|
71545
|
+
form: "single",
|
|
71546
|
+
optional: false
|
|
71547
|
+
}],
|
|
71383
71548
|
"dishwasher.getStatus": [{
|
|
71384
71549
|
name: "deviceId",
|
|
71385
71550
|
form: "single",
|
|
@@ -71390,6 +71555,11 @@ Object.freeze({
|
|
|
71390
71555
|
form: "single",
|
|
71391
71556
|
optional: false
|
|
71392
71557
|
}],
|
|
71558
|
+
"dishwasher.resume": [{
|
|
71559
|
+
name: "deviceId",
|
|
71560
|
+
form: "single",
|
|
71561
|
+
optional: false
|
|
71562
|
+
}],
|
|
71393
71563
|
"dishwasher.setChildLock": [{
|
|
71394
71564
|
name: "deviceId",
|
|
71395
71565
|
form: "single",
|
|
@@ -73683,6 +73853,9 @@ new Map(Object.entries({
|
|
|
73683
73853
|
"wrapper-update-available": "system",
|
|
73684
73854
|
"backup-completed": "system",
|
|
73685
73855
|
"export-completed": "system",
|
|
73856
|
+
"alert-critical": "system",
|
|
73857
|
+
"alert-error": "system",
|
|
73858
|
+
"alert-critical-resolved": "system",
|
|
73686
73859
|
"storage-location-low": "system",
|
|
73687
73860
|
"storage-location-critical": "system",
|
|
73688
73861
|
"storage-location-ok": "system",
|
|
@@ -73807,6 +73980,16 @@ var NC_SYSTEM_EVENT_KIND_GROUP_SPECS = [
|
|
|
73807
73980
|
"storage-location-ok"
|
|
73808
73981
|
]
|
|
73809
73982
|
},
|
|
73983
|
+
{
|
|
73984
|
+
id: "alerts",
|
|
73985
|
+
family: "system",
|
|
73986
|
+
label: "Alerts",
|
|
73987
|
+
kinds: [
|
|
73988
|
+
"alert-critical",
|
|
73989
|
+
"alert-error",
|
|
73990
|
+
"alert-critical-resolved"
|
|
73991
|
+
]
|
|
73992
|
+
},
|
|
73810
73993
|
{
|
|
73811
73994
|
id: "alarm",
|
|
73812
73995
|
family: "alarm",
|
|
@@ -73851,6 +74034,21 @@ var NC_SENSOR_RAISED_FIELD_BY_KIND = Object.freeze(Object.fromEntries(Object.ent
|
|
|
73851
74034
|
return [[descriptor.kind, field]];
|
|
73852
74035
|
})));
|
|
73853
74036
|
Object.freeze(Object.keys(NC_SENSOR_RAISED_FIELD_BY_KIND));
|
|
74037
|
+
object({
|
|
74038
|
+
phase: _enum(["raised", "resolved"]),
|
|
74039
|
+
episodeId: string().min(1),
|
|
74040
|
+
alertId: string().min(1),
|
|
74041
|
+
severity: AlertSeveritySchema,
|
|
74042
|
+
category: string(),
|
|
74043
|
+
title: string(),
|
|
74044
|
+
message: string(),
|
|
74045
|
+
sourceType: string().optional(),
|
|
74046
|
+
sourceId: string().optional(),
|
|
74047
|
+
nodeId: string().optional(),
|
|
74048
|
+
/** The alert's own action link (where the operator acts on it), when it has one. */
|
|
74049
|
+
actionUrl: string().optional(),
|
|
74050
|
+
at: number()
|
|
74051
|
+
});
|
|
73854
74052
|
var RULE_BODY_ONLY = ["body"];
|
|
73855
74053
|
var RULE_TEXT = ["title", "body"];
|
|
73856
74054
|
var BATTERY = ["device-battery-low", "device-battery-normal"];
|
|
@@ -73860,6 +74058,11 @@ var TANK = [
|
|
|
73860
74058
|
"device-tank-full",
|
|
73861
74059
|
"device-tank-normal"
|
|
73862
74060
|
];
|
|
74061
|
+
var ALERT_EPISODE = [
|
|
74062
|
+
"alert-critical",
|
|
74063
|
+
"alert-error",
|
|
74064
|
+
"alert-critical-resolved"
|
|
74065
|
+
];
|
|
73863
74066
|
var UPDATES = [
|
|
73864
74067
|
"addon-update-available",
|
|
73865
74068
|
"server-update-available",
|
|
@@ -74052,14 +74255,14 @@ var STATE_SUMMARY_VARS = [
|
|
|
74052
74255
|
([...RULE_TEXT], [...CONSUMABLE]),
|
|
74053
74256
|
([...RULE_TEXT], [...TANK]),
|
|
74054
74257
|
[...RULE_TEXT],
|
|
74055
|
-
([...RULE_TEXT], [...UPDATES]),
|
|
74056
|
-
([...RULE_TEXT], [...UPDATES]),
|
|
74057
|
-
[...RULE_TEXT],
|
|
74258
|
+
([...RULE_TEXT], [...UPDATES, ...ALERT_EPISODE]),
|
|
74259
|
+
([...RULE_TEXT], [...UPDATES, ...ALERT_EPISODE]),
|
|
74058
74260
|
[...RULE_TEXT],
|
|
74059
74261
|
[...RULE_TEXT],
|
|
74060
74262
|
[...RULE_TEXT],
|
|
74061
74263
|
[...RULE_TEXT],
|
|
74062
74264
|
[...RULE_TEXT],
|
|
74265
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
74063
74266
|
[...RULE_TEXT],
|
|
74064
74267
|
[...RULE_TEXT],
|
|
74065
74268
|
[...RULE_TEXT],
|
|
@@ -74077,7 +74280,11 @@ var STATE_SUMMARY_VARS = [
|
|
|
74077
74280
|
[...RULE_TEXT],
|
|
74078
74281
|
[...RULE_TEXT],
|
|
74079
74282
|
[...RULE_TEXT],
|
|
74080
|
-
[...RULE_TEXT],
|
|
74283
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
74284
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
74285
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
74286
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
74287
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
74081
74288
|
[...RULE_TEXT],
|
|
74082
74289
|
[...RULE_TEXT],
|
|
74083
74290
|
[...RULE_TEXT],
|
package/dist/addon.mjs
CHANGED
|
@@ -2,7 +2,7 @@ import { brotliCompressSync, deflateSync, gzipSync } from "node:zlib";
|
|
|
2
2
|
import { readFileSync } from "node:fs";
|
|
3
3
|
import path from "node:path";
|
|
4
4
|
import { fileURLToPath } from "node:url";
|
|
5
|
-
//#region ../types/dist/event-category-
|
|
5
|
+
//#region ../types/dist/event-category-DOl51-Ij.mjs
|
|
6
6
|
var EventCategory = /* @__PURE__ */ function(EventCategory) {
|
|
7
7
|
EventCategory["SystemBoot"] = "system.boot";
|
|
8
8
|
EventCategory["SystemAddonsReady"] = "system.addons-ready";
|
|
@@ -81,9 +81,18 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
|
|
|
81
81
|
/**
|
|
82
82
|
* The node's one-shot runner boot check (D877): planned runners against the
|
|
83
83
|
* process service, `degraded` when any is failed, refused or missing. The
|
|
84
|
-
* alert centre turns it into one
|
|
84
|
+
* alert centre turns it into one critical alert.
|
|
85
85
|
*/
|
|
86
86
|
EventCategory["SystemRunnerCheck"] = "system.runner-check";
|
|
87
|
+
/**
|
|
88
|
+
* An alert EPISODE opened or closed, emitted by the alert centre for alerts
|
|
89
|
+
* of severity `critical` or `error` (`AlertEpisodePayload`). The alert
|
|
90
|
+
* centre sends no notification of its own: Notification Center turns this
|
|
91
|
+
* into the `alert-critical` / `alert-error` / `alert-critical-resolved`
|
|
92
|
+
* system-event kinds, and reconciles from the alerts store because a bus
|
|
93
|
+
* event may be dropped (D8, D11).
|
|
94
|
+
*/
|
|
95
|
+
EventCategory["AlertEpisode"] = "alert.episode";
|
|
87
96
|
EventCategory["AddonError"] = "addon.error";
|
|
88
97
|
EventCategory["AddonPageReady"] = "addon.page-ready";
|
|
89
98
|
EventCategory["AddonWidgetReady"] = "addon.widget-ready";
|
|
@@ -5541,7 +5550,7 @@ var ZodIssueCode = {
|
|
|
5541
5550
|
var ZodFirstPartyTypeKind;
|
|
5542
5551
|
ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
|
|
5543
5552
|
//#endregion
|
|
5544
|
-
//#region ../types/dist/sleep-
|
|
5553
|
+
//#region ../types/dist/sleep-BxjU_fJM.mjs
|
|
5545
5554
|
/**
|
|
5546
5555
|
* The audio chunk plane's byte format, and the ONE expansion from a coded
|
|
5547
5556
|
* window to float samples (D455).
|
|
@@ -13609,7 +13618,14 @@ var AlertSeveritySchema = _enum([
|
|
|
13609
13618
|
]);
|
|
13610
13619
|
var AlertActionSchema = object({
|
|
13611
13620
|
label: string(),
|
|
13612
|
-
href: string().optional()
|
|
13621
|
+
href: string().optional(),
|
|
13622
|
+
/**
|
|
13623
|
+
* How `href` is followed. Absent / `app`: an admin-ui route (client-side).
|
|
13624
|
+
* `server`: a route the HUB serves (an addon HTTP route such as an OAuth
|
|
13625
|
+
* start) — the browser must leave the SPA with a full navigation, because
|
|
13626
|
+
* the SPA has no such route and would bounce to the home page.
|
|
13627
|
+
*/
|
|
13628
|
+
navigation: _enum(["app", "server"]).optional()
|
|
13613
13629
|
});
|
|
13614
13630
|
var AlertStatusSchema = _enum([
|
|
13615
13631
|
"active",
|
|
@@ -42007,6 +42023,9 @@ var NcSystemEventKindSchema = _enum([
|
|
|
42007
42023
|
"server-updated",
|
|
42008
42024
|
"export-completed",
|
|
42009
42025
|
"backup-completed",
|
|
42026
|
+
"alert-critical",
|
|
42027
|
+
"alert-error",
|
|
42028
|
+
"alert-critical-resolved",
|
|
42010
42029
|
"camera-online",
|
|
42011
42030
|
"camera-offline",
|
|
42012
42031
|
"camera-disabled",
|
|
@@ -51039,7 +51058,10 @@ method(StorageMigrationInputSchema, StorageMigrationPlanSchema, { auth: "admin"
|
|
|
51039
51058
|
}), method(object({ jobId: string().optional() }), StorageMigrationJobSchema.nullable(), { auth: "admin" }), method(object({ jobId: string() }), object({ cancelled: boolean() }), {
|
|
51040
51059
|
kind: "mutation",
|
|
51041
51060
|
auth: "admin"
|
|
51042
|
-
}), method(object({}), array(StorageMigrationMoverSchema).readonly(), { auth: "admin" }), method(object({
|
|
51061
|
+
}), method(object({}), array(StorageMigrationMoverSchema).readonly(), { auth: "admin" }), method(object({ locationIds: array(string()).readonly() }), object({
|
|
51062
|
+
clear: boolean(),
|
|
51063
|
+
repointLocationId: string().optional()
|
|
51064
|
+
}), { auth: "admin" }), method(object({}), array(StorageMigrationResidueSchema).readonly(), { auth: "admin" }), method(StorageMigrationDrainInputSchema, object({ jobId: string() }), {
|
|
51043
51065
|
kind: "mutation",
|
|
51044
51066
|
auth: "admin"
|
|
51045
51067
|
}), method(StorageCleanupInputSchema, object({ jobId: string() }), {
|
|
@@ -54474,6 +54496,11 @@ object({
|
|
|
54474
54496
|
*
|
|
54475
54497
|
* `kind: 'poll'` — cloud REST APIs typically have no push channel; the
|
|
54476
54498
|
* provider refreshes the slice on an interval and eagerly after commands.
|
|
54499
|
+
*
|
|
54500
|
+
* UNKNOWN IS NOT OFF. Every field the appliance reports separately is
|
|
54501
|
+
* nullable: `null` means "not known right now" (the appliance has not said,
|
|
54502
|
+
* the link is down, or the description does not carry it) and is never
|
|
54503
|
+
* rendered or exported as `false` / `0`. `availability` says why.
|
|
54477
54504
|
*/
|
|
54478
54505
|
var DishwasherStateSchema = _enum([
|
|
54479
54506
|
"idle",
|
|
@@ -54483,112 +54510,227 @@ var DishwasherStateSchema = _enum([
|
|
|
54483
54510
|
"error",
|
|
54484
54511
|
"unavailable"
|
|
54485
54512
|
]);
|
|
54513
|
+
/**
|
|
54514
|
+
* The appliance's own operation state, uncollapsed. `state` above is the coarse
|
|
54515
|
+
* view for compact surfaces; this is what the appliance said.
|
|
54516
|
+
*/
|
|
54517
|
+
var DishwasherOperationStateSchema = _enum([
|
|
54518
|
+
"Inactive",
|
|
54519
|
+
"Ready",
|
|
54520
|
+
"DelayedStart",
|
|
54521
|
+
"Run",
|
|
54522
|
+
"Pause",
|
|
54523
|
+
"ActionRequired",
|
|
54524
|
+
"Finished",
|
|
54525
|
+
"Error",
|
|
54526
|
+
"Aborting"
|
|
54527
|
+
]);
|
|
54528
|
+
/**
|
|
54529
|
+
* Why fields may be `null`:
|
|
54530
|
+
* - `available` — the link is up and the description is loaded;
|
|
54531
|
+
* - `offline` — the local link is down (values are unknown, not last-known);
|
|
54532
|
+
* - `description-missing` — the link is up but the appliance's description could not
|
|
54533
|
+
* be loaded, so its values cannot be decoded.
|
|
54534
|
+
*/
|
|
54535
|
+
var DishwasherAvailabilitySchema = _enum([
|
|
54536
|
+
"available",
|
|
54537
|
+
"offline",
|
|
54538
|
+
"description-missing"
|
|
54539
|
+
]);
|
|
54486
54540
|
var DishwasherConsumableLevelSchema = _enum([
|
|
54487
54541
|
"ok",
|
|
54488
54542
|
"low",
|
|
54489
54543
|
"empty"
|
|
54490
54544
|
]);
|
|
54491
54545
|
object({
|
|
54546
|
+
availability: DishwasherAvailabilitySchema,
|
|
54547
|
+
/** Coarse state for compact surfaces; `unavailable` whenever the appliance state is not known. */
|
|
54492
54548
|
state: DishwasherStateSchema,
|
|
54493
|
-
/**
|
|
54549
|
+
/** The appliance's operation state as reported; null when not known. */
|
|
54550
|
+
operationState: DishwasherOperationStateSchema.nullable(),
|
|
54551
|
+
/** Feature key of the ACTIVE (running) program, or null when none runs / not known. */
|
|
54494
54552
|
program: string().nullable(),
|
|
54495
|
-
/**
|
|
54553
|
+
/** Feature key of the SELECTED program (what Start would run), or null when none / not known. */
|
|
54554
|
+
selectedProgram: string().nullable(),
|
|
54555
|
+
/** Feature keys of the programs the appliance currently offers — drives the UI selector. */
|
|
54496
54556
|
availablePrograms: array(string()),
|
|
54497
|
-
/**
|
|
54498
|
-
|
|
54557
|
+
/** Seconds remaining on the active cycle, or null when not running / not known. */
|
|
54558
|
+
remainingSeconds: number().int().nonnegative().nullable(),
|
|
54559
|
+
/** Seconds the delayed start is set to (time until the cycle starts), or null. */
|
|
54560
|
+
delayedStartSeconds: number().int().nonnegative().nullable(),
|
|
54499
54561
|
/** Cycle completion 0..100, or null when not applicable. */
|
|
54500
54562
|
progressPercent: number().min(0).max(100).nullable(),
|
|
54501
|
-
/** True when the door is reported open. */
|
|
54502
|
-
doorOpen: boolean(),
|
|
54503
|
-
/** True when
|
|
54504
|
-
|
|
54505
|
-
/**
|
|
54506
|
-
|
|
54563
|
+
/** True when the door is reported open; null when the door state is not known. */
|
|
54564
|
+
doorOpen: boolean().nullable(),
|
|
54565
|
+
/** True when the door is latched (locked) during a cycle; null when not reported. */
|
|
54566
|
+
doorLocked: boolean().nullable(),
|
|
54567
|
+
/** True when remote start is allowed (door closed, power on, etc.); null when not known. */
|
|
54568
|
+
remoteStartAllowed: boolean().nullable(),
|
|
54569
|
+
/** True when the appliance accepts remote control now; null when not known. */
|
|
54570
|
+
remoteControlActive: boolean().nullable(),
|
|
54571
|
+
/** True while somebody operates the appliance at its panel; null when not reported. */
|
|
54572
|
+
localControlActive: boolean().nullable(),
|
|
54573
|
+
/** Main power / switched-on state; null when not known. */
|
|
54574
|
+
powerOn: boolean().nullable(),
|
|
54575
|
+
/** The raw power state (`On`, `Off`, `Standby`, …); null when not known. */
|
|
54576
|
+
powerState: string().nullable(),
|
|
54507
54577
|
saltLevel: DishwasherConsumableLevelSchema.nullable(),
|
|
54508
54578
|
rinseAidLevel: DishwasherConsumableLevelSchema.nullable(),
|
|
54509
|
-
|
|
54510
|
-
|
|
54579
|
+
/** Option states: null when the appliance does not expose the option or has not said. */
|
|
54580
|
+
halfLoad: boolean().nullable(),
|
|
54581
|
+
hygienePlus: boolean().nullable(),
|
|
54511
54582
|
/** Extra dry option when the appliance exposes it. */
|
|
54512
|
-
extraDry: boolean(),
|
|
54583
|
+
extraDry: boolean().nullable(),
|
|
54513
54584
|
/** Intensive zone (lower basket) when the appliance exposes it. */
|
|
54514
|
-
intensiveZone: boolean(),
|
|
54585
|
+
intensiveZone: boolean().nullable(),
|
|
54515
54586
|
/** VarioSpeed / VarioSpeed+ when the appliance exposes it. */
|
|
54516
|
-
varioSpeedPlus: boolean(),
|
|
54517
|
-
/** Child lock (controls disabled on the appliance). */
|
|
54518
|
-
childLock: boolean(),
|
|
54587
|
+
varioSpeedPlus: boolean().nullable(),
|
|
54588
|
+
/** Child lock (controls disabled on the appliance); null when not known. */
|
|
54589
|
+
childLock: boolean().nullable(),
|
|
54590
|
+
/** Feature keys of the events currently raised (salt low, rinse aid low, program finished, …). */
|
|
54591
|
+
activeEvents: array(string()),
|
|
54592
|
+
/** Numeric error code when the appliance reports one; null otherwise. */
|
|
54519
54593
|
errorCode: number().nullable(),
|
|
54594
|
+
/** Name of the raised alert-level event while the appliance is in error; null otherwise. */
|
|
54520
54595
|
errorLabel: string().nullable(),
|
|
54596
|
+
/** Ms epoch of the last value received from the appliance; 0 = never. */
|
|
54521
54597
|
lastFetchedAt: number()
|
|
54522
54598
|
});
|
|
54523
|
-
|
|
54599
|
+
var DeviceIdSchema = number().int().nonnegative();
|
|
54600
|
+
/** A value a program option or setting can take. */
|
|
54601
|
+
var DishwasherValueSchema = union([
|
|
54602
|
+
boolean(),
|
|
54603
|
+
string(),
|
|
54604
|
+
number()
|
|
54605
|
+
]);
|
|
54606
|
+
var DishwasherAccessSchema = _enum([
|
|
54607
|
+
"none",
|
|
54608
|
+
"read",
|
|
54609
|
+
"readWrite",
|
|
54610
|
+
"writeOnly",
|
|
54611
|
+
"readStatic"
|
|
54612
|
+
]);
|
|
54613
|
+
/**
|
|
54614
|
+
* One option or setting the appliance declares, with the constraints its description
|
|
54615
|
+
* gives. A `readWrite` descriptor that is `available` is what `setOption` accepts.
|
|
54616
|
+
*/
|
|
54617
|
+
var DishwasherOptionDescriptorSchema = object({
|
|
54618
|
+
/** Feature key (`Dishcare.Dishwasher.Option.ExtraDry`). */
|
|
54619
|
+
key: string(),
|
|
54620
|
+
/** Last segment of the key, for display. */
|
|
54621
|
+
name: string(),
|
|
54622
|
+
type: _enum([
|
|
54623
|
+
"boolean",
|
|
54624
|
+
"number",
|
|
54625
|
+
"enum",
|
|
54626
|
+
"string"
|
|
54627
|
+
]),
|
|
54628
|
+
access: DishwasherAccessSchema,
|
|
54629
|
+
/** The appliance reports this entity as currently available. */
|
|
54630
|
+
available: boolean(),
|
|
54631
|
+
/** Unit the description declares for a number; null when it declares none. */
|
|
54632
|
+
unit: string().nullable(),
|
|
54633
|
+
min: number().nullable(),
|
|
54634
|
+
max: number().nullable(),
|
|
54635
|
+
step: number().nullable(),
|
|
54636
|
+
/** Allowed members of an enum; null for other types. */
|
|
54637
|
+
enumValues: array(string()).nullable(),
|
|
54638
|
+
defaultValue: DishwasherValueSchema.nullable()
|
|
54639
|
+
});
|
|
54640
|
+
var DishwasherProgramSchema = object({
|
|
54641
|
+
/** Feature key (`Dishcare.Dishwasher.Program.Eco50`) — what `setProgram` / `start` take. */
|
|
54642
|
+
key: string(),
|
|
54643
|
+
name: string(),
|
|
54644
|
+
/** The appliance currently offers this program. */
|
|
54645
|
+
available: boolean(),
|
|
54646
|
+
/** The options this program lists, with the program-level access / availability / default. */
|
|
54647
|
+
options: array(DishwasherOptionDescriptorSchema)
|
|
54648
|
+
});
|
|
54649
|
+
var DishwasherOptionsSchema = object({
|
|
54650
|
+
availability: DishwasherAvailabilitySchema,
|
|
54651
|
+
/** What the appliance can be told to do, from the commands its description declares. */
|
|
54652
|
+
supportsStart: boolean(),
|
|
54653
|
+
supportsPause: boolean(),
|
|
54654
|
+
supportsResume: boolean(),
|
|
54655
|
+
supportsStop: boolean(),
|
|
54656
|
+
supportsPower: boolean(),
|
|
54657
|
+
/** Every program the description lists, with its options. */
|
|
54658
|
+
programs: array(DishwasherProgramSchema),
|
|
54659
|
+
/** Every option and setting entity the description lists (programs reference these by key). */
|
|
54660
|
+
options: array(DishwasherOptionDescriptorSchema)
|
|
54661
|
+
});
|
|
54662
|
+
DeviceType.Dishwasher, method(object({
|
|
54663
|
+
deviceId: DeviceIdSchema,
|
|
54664
|
+
program: string().min(1).optional(),
|
|
54665
|
+
options: record(string(), DishwasherValueSchema).optional()
|
|
54666
|
+
}), _void(), {
|
|
54524
54667
|
kind: "mutation",
|
|
54525
54668
|
auth: "protected"
|
|
54526
|
-
}), method(object({ deviceId:
|
|
54669
|
+
}), method(object({ deviceId: DeviceIdSchema }), _void(), {
|
|
54527
54670
|
kind: "mutation",
|
|
54528
54671
|
auth: "protected"
|
|
54529
|
-
}), method(object({ deviceId:
|
|
54672
|
+
}), method(object({ deviceId: DeviceIdSchema }), _void(), {
|
|
54673
|
+
kind: "mutation",
|
|
54674
|
+
auth: "protected"
|
|
54675
|
+
}), method(object({ deviceId: DeviceIdSchema }), _void(), {
|
|
54530
54676
|
kind: "mutation",
|
|
54531
54677
|
auth: "protected"
|
|
54532
54678
|
}), method(object({
|
|
54533
|
-
deviceId:
|
|
54679
|
+
deviceId: DeviceIdSchema,
|
|
54534
54680
|
program: string().min(1)
|
|
54535
54681
|
}), _void(), {
|
|
54536
54682
|
kind: "mutation",
|
|
54537
54683
|
auth: "protected"
|
|
54538
54684
|
}), method(object({
|
|
54539
|
-
deviceId:
|
|
54685
|
+
deviceId: DeviceIdSchema,
|
|
54540
54686
|
on: boolean()
|
|
54541
54687
|
}), _void(), {
|
|
54542
54688
|
kind: "mutation",
|
|
54543
54689
|
auth: "protected"
|
|
54544
54690
|
}), method(object({
|
|
54545
|
-
deviceId:
|
|
54691
|
+
deviceId: DeviceIdSchema,
|
|
54546
54692
|
on: boolean()
|
|
54547
54693
|
}), _void(), {
|
|
54548
54694
|
kind: "mutation",
|
|
54549
54695
|
auth: "protected"
|
|
54550
54696
|
}), method(object({
|
|
54551
|
-
deviceId:
|
|
54697
|
+
deviceId: DeviceIdSchema,
|
|
54552
54698
|
on: boolean()
|
|
54553
54699
|
}), _void(), {
|
|
54554
54700
|
kind: "mutation",
|
|
54555
54701
|
auth: "protected"
|
|
54556
54702
|
}), method(object({
|
|
54557
|
-
deviceId:
|
|
54703
|
+
deviceId: DeviceIdSchema,
|
|
54558
54704
|
on: boolean()
|
|
54559
54705
|
}), _void(), {
|
|
54560
54706
|
kind: "mutation",
|
|
54561
54707
|
auth: "protected"
|
|
54562
54708
|
}), method(object({
|
|
54563
|
-
deviceId:
|
|
54709
|
+
deviceId: DeviceIdSchema,
|
|
54564
54710
|
on: boolean()
|
|
54565
54711
|
}), _void(), {
|
|
54566
54712
|
kind: "mutation",
|
|
54567
54713
|
auth: "protected"
|
|
54568
54714
|
}), method(object({
|
|
54569
|
-
deviceId:
|
|
54715
|
+
deviceId: DeviceIdSchema,
|
|
54570
54716
|
on: boolean()
|
|
54571
54717
|
}), _void(), {
|
|
54572
54718
|
kind: "mutation",
|
|
54573
54719
|
auth: "protected"
|
|
54574
54720
|
}), method(object({
|
|
54575
|
-
deviceId:
|
|
54721
|
+
deviceId: DeviceIdSchema,
|
|
54576
54722
|
on: boolean()
|
|
54577
54723
|
}), _void(), {
|
|
54578
54724
|
kind: "mutation",
|
|
54579
54725
|
auth: "protected"
|
|
54580
54726
|
}), method(object({
|
|
54581
|
-
deviceId:
|
|
54727
|
+
deviceId: DeviceIdSchema,
|
|
54582
54728
|
key: string().min(1),
|
|
54583
|
-
value:
|
|
54584
|
-
boolean(),
|
|
54585
|
-
string(),
|
|
54586
|
-
number()
|
|
54587
|
-
])
|
|
54729
|
+
value: DishwasherValueSchema
|
|
54588
54730
|
}), _void(), {
|
|
54589
54731
|
kind: "mutation",
|
|
54590
54732
|
auth: "protected"
|
|
54591
|
-
});
|
|
54733
|
+
}), method(object({ deviceId: DeviceIdSchema }), DishwasherOptionsSchema, { auth: "protected" });
|
|
54592
54734
|
object({
|
|
54593
54735
|
/** Ms epoch of the last press. null = never observed since this provider started. */
|
|
54594
54736
|
lastPressedAt: number().nullable(),
|
|
@@ -64648,6 +64790,12 @@ Object.freeze({
|
|
|
64648
64790
|
addonId: null,
|
|
64649
64791
|
access: "view"
|
|
64650
64792
|
},
|
|
64793
|
+
"dishwasher.getOptions": {
|
|
64794
|
+
capName: "dishwasher",
|
|
64795
|
+
capScope: "device",
|
|
64796
|
+
addonId: null,
|
|
64797
|
+
access: "view"
|
|
64798
|
+
},
|
|
64651
64799
|
"dishwasher.getStatus": {
|
|
64652
64800
|
capName: "dishwasher",
|
|
64653
64801
|
capScope: "device",
|
|
@@ -64660,6 +64808,12 @@ Object.freeze({
|
|
|
64660
64808
|
addonId: null,
|
|
64661
64809
|
access: "create"
|
|
64662
64810
|
},
|
|
64811
|
+
"dishwasher.resume": {
|
|
64812
|
+
capName: "dishwasher",
|
|
64813
|
+
capScope: "device",
|
|
64814
|
+
addonId: null,
|
|
64815
|
+
access: "create"
|
|
64816
|
+
},
|
|
64663
64817
|
"dishwasher.setChildLock": {
|
|
64664
64818
|
capName: "dishwasher",
|
|
64665
64819
|
capScope: "device",
|
|
@@ -69160,6 +69314,12 @@ Object.freeze({
|
|
|
69160
69314
|
addonId: null,
|
|
69161
69315
|
access: "view"
|
|
69162
69316
|
},
|
|
69317
|
+
"storageMigration.moverClearance": {
|
|
69318
|
+
capName: "storage-migration",
|
|
69319
|
+
capScope: "system",
|
|
69320
|
+
addonId: null,
|
|
69321
|
+
access: "view"
|
|
69322
|
+
},
|
|
69163
69323
|
"storageMigration.movers": {
|
|
69164
69324
|
capName: "storage-migration",
|
|
69165
69325
|
capScope: "system",
|
|
@@ -71353,6 +71513,11 @@ Object.freeze({
|
|
|
71353
71513
|
form: "single",
|
|
71354
71514
|
optional: false
|
|
71355
71515
|
}],
|
|
71516
|
+
"dishwasher.getOptions": [{
|
|
71517
|
+
name: "deviceId",
|
|
71518
|
+
form: "single",
|
|
71519
|
+
optional: false
|
|
71520
|
+
}],
|
|
71356
71521
|
"dishwasher.getStatus": [{
|
|
71357
71522
|
name: "deviceId",
|
|
71358
71523
|
form: "single",
|
|
@@ -71363,6 +71528,11 @@ Object.freeze({
|
|
|
71363
71528
|
form: "single",
|
|
71364
71529
|
optional: false
|
|
71365
71530
|
}],
|
|
71531
|
+
"dishwasher.resume": [{
|
|
71532
|
+
name: "deviceId",
|
|
71533
|
+
form: "single",
|
|
71534
|
+
optional: false
|
|
71535
|
+
}],
|
|
71366
71536
|
"dishwasher.setChildLock": [{
|
|
71367
71537
|
name: "deviceId",
|
|
71368
71538
|
form: "single",
|
|
@@ -73656,6 +73826,9 @@ new Map(Object.entries({
|
|
|
73656
73826
|
"wrapper-update-available": "system",
|
|
73657
73827
|
"backup-completed": "system",
|
|
73658
73828
|
"export-completed": "system",
|
|
73829
|
+
"alert-critical": "system",
|
|
73830
|
+
"alert-error": "system",
|
|
73831
|
+
"alert-critical-resolved": "system",
|
|
73659
73832
|
"storage-location-low": "system",
|
|
73660
73833
|
"storage-location-critical": "system",
|
|
73661
73834
|
"storage-location-ok": "system",
|
|
@@ -73780,6 +73953,16 @@ var NC_SYSTEM_EVENT_KIND_GROUP_SPECS = [
|
|
|
73780
73953
|
"storage-location-ok"
|
|
73781
73954
|
]
|
|
73782
73955
|
},
|
|
73956
|
+
{
|
|
73957
|
+
id: "alerts",
|
|
73958
|
+
family: "system",
|
|
73959
|
+
label: "Alerts",
|
|
73960
|
+
kinds: [
|
|
73961
|
+
"alert-critical",
|
|
73962
|
+
"alert-error",
|
|
73963
|
+
"alert-critical-resolved"
|
|
73964
|
+
]
|
|
73965
|
+
},
|
|
73783
73966
|
{
|
|
73784
73967
|
id: "alarm",
|
|
73785
73968
|
family: "alarm",
|
|
@@ -73824,6 +74007,21 @@ var NC_SENSOR_RAISED_FIELD_BY_KIND = Object.freeze(Object.fromEntries(Object.ent
|
|
|
73824
74007
|
return [[descriptor.kind, field]];
|
|
73825
74008
|
})));
|
|
73826
74009
|
Object.freeze(Object.keys(NC_SENSOR_RAISED_FIELD_BY_KIND));
|
|
74010
|
+
object({
|
|
74011
|
+
phase: _enum(["raised", "resolved"]),
|
|
74012
|
+
episodeId: string().min(1),
|
|
74013
|
+
alertId: string().min(1),
|
|
74014
|
+
severity: AlertSeveritySchema,
|
|
74015
|
+
category: string(),
|
|
74016
|
+
title: string(),
|
|
74017
|
+
message: string(),
|
|
74018
|
+
sourceType: string().optional(),
|
|
74019
|
+
sourceId: string().optional(),
|
|
74020
|
+
nodeId: string().optional(),
|
|
74021
|
+
/** The alert's own action link (where the operator acts on it), when it has one. */
|
|
74022
|
+
actionUrl: string().optional(),
|
|
74023
|
+
at: number()
|
|
74024
|
+
});
|
|
73827
74025
|
var RULE_BODY_ONLY = ["body"];
|
|
73828
74026
|
var RULE_TEXT = ["title", "body"];
|
|
73829
74027
|
var BATTERY = ["device-battery-low", "device-battery-normal"];
|
|
@@ -73833,6 +74031,11 @@ var TANK = [
|
|
|
73833
74031
|
"device-tank-full",
|
|
73834
74032
|
"device-tank-normal"
|
|
73835
74033
|
];
|
|
74034
|
+
var ALERT_EPISODE = [
|
|
74035
|
+
"alert-critical",
|
|
74036
|
+
"alert-error",
|
|
74037
|
+
"alert-critical-resolved"
|
|
74038
|
+
];
|
|
73836
74039
|
var UPDATES = [
|
|
73837
74040
|
"addon-update-available",
|
|
73838
74041
|
"server-update-available",
|
|
@@ -74025,14 +74228,14 @@ var STATE_SUMMARY_VARS = [
|
|
|
74025
74228
|
([...RULE_TEXT], [...CONSUMABLE]),
|
|
74026
74229
|
([...RULE_TEXT], [...TANK]),
|
|
74027
74230
|
[...RULE_TEXT],
|
|
74028
|
-
([...RULE_TEXT], [...UPDATES]),
|
|
74029
|
-
([...RULE_TEXT], [...UPDATES]),
|
|
74030
|
-
[...RULE_TEXT],
|
|
74231
|
+
([...RULE_TEXT], [...UPDATES, ...ALERT_EPISODE]),
|
|
74232
|
+
([...RULE_TEXT], [...UPDATES, ...ALERT_EPISODE]),
|
|
74031
74233
|
[...RULE_TEXT],
|
|
74032
74234
|
[...RULE_TEXT],
|
|
74033
74235
|
[...RULE_TEXT],
|
|
74034
74236
|
[...RULE_TEXT],
|
|
74035
74237
|
[...RULE_TEXT],
|
|
74238
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
74036
74239
|
[...RULE_TEXT],
|
|
74037
74240
|
[...RULE_TEXT],
|
|
74038
74241
|
[...RULE_TEXT],
|
|
@@ -74050,7 +74253,11 @@ var STATE_SUMMARY_VARS = [
|
|
|
74050
74253
|
[...RULE_TEXT],
|
|
74051
74254
|
[...RULE_TEXT],
|
|
74052
74255
|
[...RULE_TEXT],
|
|
74053
|
-
[...RULE_TEXT],
|
|
74256
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
74257
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
74258
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
74259
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
74260
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
74054
74261
|
[...RULE_TEXT],
|
|
74055
74262
|
[...RULE_TEXT],
|
|
74056
74263
|
[...RULE_TEXT],
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@camstack/addon-notifiers",
|
|
3
|
-
"version": "1.2.
|
|
3
|
+
"version": "1.2.603",
|
|
4
4
|
"description": "System notifiers addon for CamStack — a `notification-output` collection provider hosting per-kind notifier adapters (ntfy, pushover, gotify, telegram, discord, webhook, zentik).",
|
|
5
5
|
"keywords": [
|
|
6
6
|
"camstack",
|