@camstack/addon-mqtt-broker 1.2.127 → 1.2.128
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/mqtt-broker.addon.js +251 -44
- package/dist/mqtt-broker.addon.mjs +251 -44
- package/package.json +1 -1
|
@@ -46,7 +46,7 @@ let node_fs = require("node:fs");
|
|
|
46
46
|
node_fs = __toESM(node_fs);
|
|
47
47
|
let node_path = require("node:path");
|
|
48
48
|
node_path = __toESM(node_path);
|
|
49
|
-
//#region ../types/dist/event-category-
|
|
49
|
+
//#region ../types/dist/event-category-DOl51-Ij.mjs
|
|
50
50
|
var EventCategory = /* @__PURE__ */ function(EventCategory) {
|
|
51
51
|
EventCategory["SystemBoot"] = "system.boot";
|
|
52
52
|
EventCategory["SystemAddonsReady"] = "system.addons-ready";
|
|
@@ -125,9 +125,18 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
|
|
|
125
125
|
/**
|
|
126
126
|
* The node's one-shot runner boot check (D877): planned runners against the
|
|
127
127
|
* process service, `degraded` when any is failed, refused or missing. The
|
|
128
|
-
* alert centre turns it into one
|
|
128
|
+
* alert centre turns it into one critical alert.
|
|
129
129
|
*/
|
|
130
130
|
EventCategory["SystemRunnerCheck"] = "system.runner-check";
|
|
131
|
+
/**
|
|
132
|
+
* An alert EPISODE opened or closed, emitted by the alert centre for alerts
|
|
133
|
+
* of severity `critical` or `error` (`AlertEpisodePayload`). The alert
|
|
134
|
+
* centre sends no notification of its own: Notification Center turns this
|
|
135
|
+
* into the `alert-critical` / `alert-error` / `alert-critical-resolved`
|
|
136
|
+
* system-event kinds, and reconciles from the alerts store because a bus
|
|
137
|
+
* event may be dropped (D8, D11).
|
|
138
|
+
*/
|
|
139
|
+
EventCategory["AlertEpisode"] = "alert.episode";
|
|
131
140
|
EventCategory["AddonError"] = "addon.error";
|
|
132
141
|
EventCategory["AddonPageReady"] = "addon.page-ready";
|
|
133
142
|
EventCategory["AddonWidgetReady"] = "addon.widget-ready";
|
|
@@ -5585,7 +5594,7 @@ var ZodIssueCode = {
|
|
|
5585
5594
|
var ZodFirstPartyTypeKind;
|
|
5586
5595
|
ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
|
|
5587
5596
|
//#endregion
|
|
5588
|
-
//#region ../types/dist/sleep-
|
|
5597
|
+
//#region ../types/dist/sleep-BxjU_fJM.mjs
|
|
5589
5598
|
/**
|
|
5590
5599
|
* The audio chunk plane's byte format, and the ONE expansion from a coded
|
|
5591
5600
|
* window to float samples (D455).
|
|
@@ -13543,7 +13552,14 @@ var AlertSeveritySchema = _enum([
|
|
|
13543
13552
|
]);
|
|
13544
13553
|
var AlertActionSchema = object({
|
|
13545
13554
|
label: string(),
|
|
13546
|
-
href: string().optional()
|
|
13555
|
+
href: string().optional(),
|
|
13556
|
+
/**
|
|
13557
|
+
* How `href` is followed. Absent / `app`: an admin-ui route (client-side).
|
|
13558
|
+
* `server`: a route the HUB serves (an addon HTTP route such as an OAuth
|
|
13559
|
+
* start) — the browser must leave the SPA with a full navigation, because
|
|
13560
|
+
* the SPA has no such route and would bounce to the home page.
|
|
13561
|
+
*/
|
|
13562
|
+
navigation: _enum(["app", "server"]).optional()
|
|
13547
13563
|
});
|
|
13548
13564
|
var AlertStatusSchema = _enum([
|
|
13549
13565
|
"active",
|
|
@@ -41987,6 +42003,9 @@ var NcSystemEventKindSchema = _enum([
|
|
|
41987
42003
|
"server-updated",
|
|
41988
42004
|
"export-completed",
|
|
41989
42005
|
"backup-completed",
|
|
42006
|
+
"alert-critical",
|
|
42007
|
+
"alert-error",
|
|
42008
|
+
"alert-critical-resolved",
|
|
41990
42009
|
"camera-online",
|
|
41991
42010
|
"camera-offline",
|
|
41992
42011
|
"camera-disabled",
|
|
@@ -51019,7 +51038,10 @@ method(StorageMigrationInputSchema, StorageMigrationPlanSchema, { auth: "admin"
|
|
|
51019
51038
|
}), method(object({ jobId: string().optional() }), StorageMigrationJobSchema.nullable(), { auth: "admin" }), method(object({ jobId: string() }), object({ cancelled: boolean() }), {
|
|
51020
51039
|
kind: "mutation",
|
|
51021
51040
|
auth: "admin"
|
|
51022
|
-
}), method(object({}), array(StorageMigrationMoverSchema).readonly(), { auth: "admin" }), method(object({
|
|
51041
|
+
}), method(object({}), array(StorageMigrationMoverSchema).readonly(), { auth: "admin" }), method(object({ locationIds: array(string()).readonly() }), object({
|
|
51042
|
+
clear: boolean(),
|
|
51043
|
+
repointLocationId: string().optional()
|
|
51044
|
+
}), { auth: "admin" }), method(object({}), array(StorageMigrationResidueSchema).readonly(), { auth: "admin" }), method(StorageMigrationDrainInputSchema, object({ jobId: string() }), {
|
|
51023
51045
|
kind: "mutation",
|
|
51024
51046
|
auth: "admin"
|
|
51025
51047
|
}), method(StorageCleanupInputSchema, object({ jobId: string() }), {
|
|
@@ -54454,6 +54476,11 @@ object({
|
|
|
54454
54476
|
*
|
|
54455
54477
|
* `kind: 'poll'` — cloud REST APIs typically have no push channel; the
|
|
54456
54478
|
* provider refreshes the slice on an interval and eagerly after commands.
|
|
54479
|
+
*
|
|
54480
|
+
* UNKNOWN IS NOT OFF. Every field the appliance reports separately is
|
|
54481
|
+
* nullable: `null` means "not known right now" (the appliance has not said,
|
|
54482
|
+
* the link is down, or the description does not carry it) and is never
|
|
54483
|
+
* rendered or exported as `false` / `0`. `availability` says why.
|
|
54457
54484
|
*/
|
|
54458
54485
|
var DishwasherStateSchema = _enum([
|
|
54459
54486
|
"idle",
|
|
@@ -54463,112 +54490,227 @@ var DishwasherStateSchema = _enum([
|
|
|
54463
54490
|
"error",
|
|
54464
54491
|
"unavailable"
|
|
54465
54492
|
]);
|
|
54493
|
+
/**
|
|
54494
|
+
* The appliance's own operation state, uncollapsed. `state` above is the coarse
|
|
54495
|
+
* view for compact surfaces; this is what the appliance said.
|
|
54496
|
+
*/
|
|
54497
|
+
var DishwasherOperationStateSchema = _enum([
|
|
54498
|
+
"Inactive",
|
|
54499
|
+
"Ready",
|
|
54500
|
+
"DelayedStart",
|
|
54501
|
+
"Run",
|
|
54502
|
+
"Pause",
|
|
54503
|
+
"ActionRequired",
|
|
54504
|
+
"Finished",
|
|
54505
|
+
"Error",
|
|
54506
|
+
"Aborting"
|
|
54507
|
+
]);
|
|
54508
|
+
/**
|
|
54509
|
+
* Why fields may be `null`:
|
|
54510
|
+
* - `available` — the link is up and the description is loaded;
|
|
54511
|
+
* - `offline` — the local link is down (values are unknown, not last-known);
|
|
54512
|
+
* - `description-missing` — the link is up but the appliance's description could not
|
|
54513
|
+
* be loaded, so its values cannot be decoded.
|
|
54514
|
+
*/
|
|
54515
|
+
var DishwasherAvailabilitySchema = _enum([
|
|
54516
|
+
"available",
|
|
54517
|
+
"offline",
|
|
54518
|
+
"description-missing"
|
|
54519
|
+
]);
|
|
54466
54520
|
var DishwasherConsumableLevelSchema = _enum([
|
|
54467
54521
|
"ok",
|
|
54468
54522
|
"low",
|
|
54469
54523
|
"empty"
|
|
54470
54524
|
]);
|
|
54471
54525
|
object({
|
|
54526
|
+
availability: DishwasherAvailabilitySchema,
|
|
54527
|
+
/** Coarse state for compact surfaces; `unavailable` whenever the appliance state is not known. */
|
|
54472
54528
|
state: DishwasherStateSchema,
|
|
54473
|
-
/**
|
|
54529
|
+
/** The appliance's operation state as reported; null when not known. */
|
|
54530
|
+
operationState: DishwasherOperationStateSchema.nullable(),
|
|
54531
|
+
/** Feature key of the ACTIVE (running) program, or null when none runs / not known. */
|
|
54474
54532
|
program: string().nullable(),
|
|
54475
|
-
/**
|
|
54533
|
+
/** Feature key of the SELECTED program (what Start would run), or null when none / not known. */
|
|
54534
|
+
selectedProgram: string().nullable(),
|
|
54535
|
+
/** Feature keys of the programs the appliance currently offers — drives the UI selector. */
|
|
54476
54536
|
availablePrograms: array(string()),
|
|
54477
|
-
/**
|
|
54478
|
-
|
|
54537
|
+
/** Seconds remaining on the active cycle, or null when not running / not known. */
|
|
54538
|
+
remainingSeconds: number().int().nonnegative().nullable(),
|
|
54539
|
+
/** Seconds the delayed start is set to (time until the cycle starts), or null. */
|
|
54540
|
+
delayedStartSeconds: number().int().nonnegative().nullable(),
|
|
54479
54541
|
/** Cycle completion 0..100, or null when not applicable. */
|
|
54480
54542
|
progressPercent: number().min(0).max(100).nullable(),
|
|
54481
|
-
/** True when the door is reported open. */
|
|
54482
|
-
doorOpen: boolean(),
|
|
54483
|
-
/** True when
|
|
54484
|
-
|
|
54485
|
-
/**
|
|
54486
|
-
|
|
54543
|
+
/** True when the door is reported open; null when the door state is not known. */
|
|
54544
|
+
doorOpen: boolean().nullable(),
|
|
54545
|
+
/** True when the door is latched (locked) during a cycle; null when not reported. */
|
|
54546
|
+
doorLocked: boolean().nullable(),
|
|
54547
|
+
/** True when remote start is allowed (door closed, power on, etc.); null when not known. */
|
|
54548
|
+
remoteStartAllowed: boolean().nullable(),
|
|
54549
|
+
/** True when the appliance accepts remote control now; null when not known. */
|
|
54550
|
+
remoteControlActive: boolean().nullable(),
|
|
54551
|
+
/** True while somebody operates the appliance at its panel; null when not reported. */
|
|
54552
|
+
localControlActive: boolean().nullable(),
|
|
54553
|
+
/** Main power / switched-on state; null when not known. */
|
|
54554
|
+
powerOn: boolean().nullable(),
|
|
54555
|
+
/** The raw power state (`On`, `Off`, `Standby`, …); null when not known. */
|
|
54556
|
+
powerState: string().nullable(),
|
|
54487
54557
|
saltLevel: DishwasherConsumableLevelSchema.nullable(),
|
|
54488
54558
|
rinseAidLevel: DishwasherConsumableLevelSchema.nullable(),
|
|
54489
|
-
|
|
54490
|
-
|
|
54559
|
+
/** Option states: null when the appliance does not expose the option or has not said. */
|
|
54560
|
+
halfLoad: boolean().nullable(),
|
|
54561
|
+
hygienePlus: boolean().nullable(),
|
|
54491
54562
|
/** Extra dry option when the appliance exposes it. */
|
|
54492
|
-
extraDry: boolean(),
|
|
54563
|
+
extraDry: boolean().nullable(),
|
|
54493
54564
|
/** Intensive zone (lower basket) when the appliance exposes it. */
|
|
54494
|
-
intensiveZone: boolean(),
|
|
54565
|
+
intensiveZone: boolean().nullable(),
|
|
54495
54566
|
/** VarioSpeed / VarioSpeed+ when the appliance exposes it. */
|
|
54496
|
-
varioSpeedPlus: boolean(),
|
|
54497
|
-
/** Child lock (controls disabled on the appliance). */
|
|
54498
|
-
childLock: boolean(),
|
|
54567
|
+
varioSpeedPlus: boolean().nullable(),
|
|
54568
|
+
/** Child lock (controls disabled on the appliance); null when not known. */
|
|
54569
|
+
childLock: boolean().nullable(),
|
|
54570
|
+
/** Feature keys of the events currently raised (salt low, rinse aid low, program finished, …). */
|
|
54571
|
+
activeEvents: array(string()),
|
|
54572
|
+
/** Numeric error code when the appliance reports one; null otherwise. */
|
|
54499
54573
|
errorCode: number().nullable(),
|
|
54574
|
+
/** Name of the raised alert-level event while the appliance is in error; null otherwise. */
|
|
54500
54575
|
errorLabel: string().nullable(),
|
|
54576
|
+
/** Ms epoch of the last value received from the appliance; 0 = never. */
|
|
54501
54577
|
lastFetchedAt: number()
|
|
54502
54578
|
});
|
|
54503
|
-
|
|
54579
|
+
var DeviceIdSchema = number().int().nonnegative();
|
|
54580
|
+
/** A value a program option or setting can take. */
|
|
54581
|
+
var DishwasherValueSchema = union([
|
|
54582
|
+
boolean(),
|
|
54583
|
+
string(),
|
|
54584
|
+
number()
|
|
54585
|
+
]);
|
|
54586
|
+
var DishwasherAccessSchema = _enum([
|
|
54587
|
+
"none",
|
|
54588
|
+
"read",
|
|
54589
|
+
"readWrite",
|
|
54590
|
+
"writeOnly",
|
|
54591
|
+
"readStatic"
|
|
54592
|
+
]);
|
|
54593
|
+
/**
|
|
54594
|
+
* One option or setting the appliance declares, with the constraints its description
|
|
54595
|
+
* gives. A `readWrite` descriptor that is `available` is what `setOption` accepts.
|
|
54596
|
+
*/
|
|
54597
|
+
var DishwasherOptionDescriptorSchema = object({
|
|
54598
|
+
/** Feature key (`Dishcare.Dishwasher.Option.ExtraDry`). */
|
|
54599
|
+
key: string(),
|
|
54600
|
+
/** Last segment of the key, for display. */
|
|
54601
|
+
name: string(),
|
|
54602
|
+
type: _enum([
|
|
54603
|
+
"boolean",
|
|
54604
|
+
"number",
|
|
54605
|
+
"enum",
|
|
54606
|
+
"string"
|
|
54607
|
+
]),
|
|
54608
|
+
access: DishwasherAccessSchema,
|
|
54609
|
+
/** The appliance reports this entity as currently available. */
|
|
54610
|
+
available: boolean(),
|
|
54611
|
+
/** Unit the description declares for a number; null when it declares none. */
|
|
54612
|
+
unit: string().nullable(),
|
|
54613
|
+
min: number().nullable(),
|
|
54614
|
+
max: number().nullable(),
|
|
54615
|
+
step: number().nullable(),
|
|
54616
|
+
/** Allowed members of an enum; null for other types. */
|
|
54617
|
+
enumValues: array(string()).nullable(),
|
|
54618
|
+
defaultValue: DishwasherValueSchema.nullable()
|
|
54619
|
+
});
|
|
54620
|
+
var DishwasherProgramSchema = object({
|
|
54621
|
+
/** Feature key (`Dishcare.Dishwasher.Program.Eco50`) — what `setProgram` / `start` take. */
|
|
54622
|
+
key: string(),
|
|
54623
|
+
name: string(),
|
|
54624
|
+
/** The appliance currently offers this program. */
|
|
54625
|
+
available: boolean(),
|
|
54626
|
+
/** The options this program lists, with the program-level access / availability / default. */
|
|
54627
|
+
options: array(DishwasherOptionDescriptorSchema)
|
|
54628
|
+
});
|
|
54629
|
+
var DishwasherOptionsSchema = object({
|
|
54630
|
+
availability: DishwasherAvailabilitySchema,
|
|
54631
|
+
/** What the appliance can be told to do, from the commands its description declares. */
|
|
54632
|
+
supportsStart: boolean(),
|
|
54633
|
+
supportsPause: boolean(),
|
|
54634
|
+
supportsResume: boolean(),
|
|
54635
|
+
supportsStop: boolean(),
|
|
54636
|
+
supportsPower: boolean(),
|
|
54637
|
+
/** Every program the description lists, with its options. */
|
|
54638
|
+
programs: array(DishwasherProgramSchema),
|
|
54639
|
+
/** Every option and setting entity the description lists (programs reference these by key). */
|
|
54640
|
+
options: array(DishwasherOptionDescriptorSchema)
|
|
54641
|
+
});
|
|
54642
|
+
DeviceType.Dishwasher, method(object({
|
|
54643
|
+
deviceId: DeviceIdSchema,
|
|
54644
|
+
program: string().min(1).optional(),
|
|
54645
|
+
options: record(string(), DishwasherValueSchema).optional()
|
|
54646
|
+
}), _void(), {
|
|
54504
54647
|
kind: "mutation",
|
|
54505
54648
|
auth: "protected"
|
|
54506
|
-
}), method(object({ deviceId:
|
|
54649
|
+
}), method(object({ deviceId: DeviceIdSchema }), _void(), {
|
|
54507
54650
|
kind: "mutation",
|
|
54508
54651
|
auth: "protected"
|
|
54509
|
-
}), method(object({ deviceId:
|
|
54652
|
+
}), method(object({ deviceId: DeviceIdSchema }), _void(), {
|
|
54653
|
+
kind: "mutation",
|
|
54654
|
+
auth: "protected"
|
|
54655
|
+
}), method(object({ deviceId: DeviceIdSchema }), _void(), {
|
|
54510
54656
|
kind: "mutation",
|
|
54511
54657
|
auth: "protected"
|
|
54512
54658
|
}), method(object({
|
|
54513
|
-
deviceId:
|
|
54659
|
+
deviceId: DeviceIdSchema,
|
|
54514
54660
|
program: string().min(1)
|
|
54515
54661
|
}), _void(), {
|
|
54516
54662
|
kind: "mutation",
|
|
54517
54663
|
auth: "protected"
|
|
54518
54664
|
}), method(object({
|
|
54519
|
-
deviceId:
|
|
54665
|
+
deviceId: DeviceIdSchema,
|
|
54520
54666
|
on: boolean()
|
|
54521
54667
|
}), _void(), {
|
|
54522
54668
|
kind: "mutation",
|
|
54523
54669
|
auth: "protected"
|
|
54524
54670
|
}), method(object({
|
|
54525
|
-
deviceId:
|
|
54671
|
+
deviceId: DeviceIdSchema,
|
|
54526
54672
|
on: boolean()
|
|
54527
54673
|
}), _void(), {
|
|
54528
54674
|
kind: "mutation",
|
|
54529
54675
|
auth: "protected"
|
|
54530
54676
|
}), method(object({
|
|
54531
|
-
deviceId:
|
|
54677
|
+
deviceId: DeviceIdSchema,
|
|
54532
54678
|
on: boolean()
|
|
54533
54679
|
}), _void(), {
|
|
54534
54680
|
kind: "mutation",
|
|
54535
54681
|
auth: "protected"
|
|
54536
54682
|
}), method(object({
|
|
54537
|
-
deviceId:
|
|
54683
|
+
deviceId: DeviceIdSchema,
|
|
54538
54684
|
on: boolean()
|
|
54539
54685
|
}), _void(), {
|
|
54540
54686
|
kind: "mutation",
|
|
54541
54687
|
auth: "protected"
|
|
54542
54688
|
}), method(object({
|
|
54543
|
-
deviceId:
|
|
54689
|
+
deviceId: DeviceIdSchema,
|
|
54544
54690
|
on: boolean()
|
|
54545
54691
|
}), _void(), {
|
|
54546
54692
|
kind: "mutation",
|
|
54547
54693
|
auth: "protected"
|
|
54548
54694
|
}), method(object({
|
|
54549
|
-
deviceId:
|
|
54695
|
+
deviceId: DeviceIdSchema,
|
|
54550
54696
|
on: boolean()
|
|
54551
54697
|
}), _void(), {
|
|
54552
54698
|
kind: "mutation",
|
|
54553
54699
|
auth: "protected"
|
|
54554
54700
|
}), method(object({
|
|
54555
|
-
deviceId:
|
|
54701
|
+
deviceId: DeviceIdSchema,
|
|
54556
54702
|
on: boolean()
|
|
54557
54703
|
}), _void(), {
|
|
54558
54704
|
kind: "mutation",
|
|
54559
54705
|
auth: "protected"
|
|
54560
54706
|
}), method(object({
|
|
54561
|
-
deviceId:
|
|
54707
|
+
deviceId: DeviceIdSchema,
|
|
54562
54708
|
key: string().min(1),
|
|
54563
|
-
value:
|
|
54564
|
-
boolean(),
|
|
54565
|
-
string(),
|
|
54566
|
-
number()
|
|
54567
|
-
])
|
|
54709
|
+
value: DishwasherValueSchema
|
|
54568
54710
|
}), _void(), {
|
|
54569
54711
|
kind: "mutation",
|
|
54570
54712
|
auth: "protected"
|
|
54571
|
-
});
|
|
54713
|
+
}), method(object({ deviceId: DeviceIdSchema }), DishwasherOptionsSchema, { auth: "protected" });
|
|
54572
54714
|
object({
|
|
54573
54715
|
/** Ms epoch of the last press. null = never observed since this provider started. */
|
|
54574
54716
|
lastPressedAt: number().nullable(),
|
|
@@ -64628,6 +64770,12 @@ Object.freeze({
|
|
|
64628
64770
|
addonId: null,
|
|
64629
64771
|
access: "view"
|
|
64630
64772
|
},
|
|
64773
|
+
"dishwasher.getOptions": {
|
|
64774
|
+
capName: "dishwasher",
|
|
64775
|
+
capScope: "device",
|
|
64776
|
+
addonId: null,
|
|
64777
|
+
access: "view"
|
|
64778
|
+
},
|
|
64631
64779
|
"dishwasher.getStatus": {
|
|
64632
64780
|
capName: "dishwasher",
|
|
64633
64781
|
capScope: "device",
|
|
@@ -64640,6 +64788,12 @@ Object.freeze({
|
|
|
64640
64788
|
addonId: null,
|
|
64641
64789
|
access: "create"
|
|
64642
64790
|
},
|
|
64791
|
+
"dishwasher.resume": {
|
|
64792
|
+
capName: "dishwasher",
|
|
64793
|
+
capScope: "device",
|
|
64794
|
+
addonId: null,
|
|
64795
|
+
access: "create"
|
|
64796
|
+
},
|
|
64643
64797
|
"dishwasher.setChildLock": {
|
|
64644
64798
|
capName: "dishwasher",
|
|
64645
64799
|
capScope: "device",
|
|
@@ -69140,6 +69294,12 @@ Object.freeze({
|
|
|
69140
69294
|
addonId: null,
|
|
69141
69295
|
access: "view"
|
|
69142
69296
|
},
|
|
69297
|
+
"storageMigration.moverClearance": {
|
|
69298
|
+
capName: "storage-migration",
|
|
69299
|
+
capScope: "system",
|
|
69300
|
+
addonId: null,
|
|
69301
|
+
access: "view"
|
|
69302
|
+
},
|
|
69143
69303
|
"storageMigration.movers": {
|
|
69144
69304
|
capName: "storage-migration",
|
|
69145
69305
|
capScope: "system",
|
|
@@ -71333,6 +71493,11 @@ Object.freeze({
|
|
|
71333
71493
|
form: "single",
|
|
71334
71494
|
optional: false
|
|
71335
71495
|
}],
|
|
71496
|
+
"dishwasher.getOptions": [{
|
|
71497
|
+
name: "deviceId",
|
|
71498
|
+
form: "single",
|
|
71499
|
+
optional: false
|
|
71500
|
+
}],
|
|
71336
71501
|
"dishwasher.getStatus": [{
|
|
71337
71502
|
name: "deviceId",
|
|
71338
71503
|
form: "single",
|
|
@@ -71343,6 +71508,11 @@ Object.freeze({
|
|
|
71343
71508
|
form: "single",
|
|
71344
71509
|
optional: false
|
|
71345
71510
|
}],
|
|
71511
|
+
"dishwasher.resume": [{
|
|
71512
|
+
name: "deviceId",
|
|
71513
|
+
form: "single",
|
|
71514
|
+
optional: false
|
|
71515
|
+
}],
|
|
71346
71516
|
"dishwasher.setChildLock": [{
|
|
71347
71517
|
name: "deviceId",
|
|
71348
71518
|
form: "single",
|
|
@@ -73429,6 +73599,9 @@ new Map(Object.entries({
|
|
|
73429
73599
|
"wrapper-update-available": "system",
|
|
73430
73600
|
"backup-completed": "system",
|
|
73431
73601
|
"export-completed": "system",
|
|
73602
|
+
"alert-critical": "system",
|
|
73603
|
+
"alert-error": "system",
|
|
73604
|
+
"alert-critical-resolved": "system",
|
|
73432
73605
|
"storage-location-low": "system",
|
|
73433
73606
|
"storage-location-critical": "system",
|
|
73434
73607
|
"storage-location-ok": "system",
|
|
@@ -73553,6 +73726,16 @@ var NC_SYSTEM_EVENT_KIND_GROUP_SPECS = [
|
|
|
73553
73726
|
"storage-location-ok"
|
|
73554
73727
|
]
|
|
73555
73728
|
},
|
|
73729
|
+
{
|
|
73730
|
+
id: "alerts",
|
|
73731
|
+
family: "system",
|
|
73732
|
+
label: "Alerts",
|
|
73733
|
+
kinds: [
|
|
73734
|
+
"alert-critical",
|
|
73735
|
+
"alert-error",
|
|
73736
|
+
"alert-critical-resolved"
|
|
73737
|
+
]
|
|
73738
|
+
},
|
|
73556
73739
|
{
|
|
73557
73740
|
id: "alarm",
|
|
73558
73741
|
family: "alarm",
|
|
@@ -73597,6 +73780,21 @@ var NC_SENSOR_RAISED_FIELD_BY_KIND = Object.freeze(Object.fromEntries(Object.ent
|
|
|
73597
73780
|
return [[descriptor.kind, field]];
|
|
73598
73781
|
})));
|
|
73599
73782
|
Object.freeze(Object.keys(NC_SENSOR_RAISED_FIELD_BY_KIND));
|
|
73783
|
+
object({
|
|
73784
|
+
phase: _enum(["raised", "resolved"]),
|
|
73785
|
+
episodeId: string().min(1),
|
|
73786
|
+
alertId: string().min(1),
|
|
73787
|
+
severity: AlertSeveritySchema,
|
|
73788
|
+
category: string(),
|
|
73789
|
+
title: string(),
|
|
73790
|
+
message: string(),
|
|
73791
|
+
sourceType: string().optional(),
|
|
73792
|
+
sourceId: string().optional(),
|
|
73793
|
+
nodeId: string().optional(),
|
|
73794
|
+
/** The alert's own action link (where the operator acts on it), when it has one. */
|
|
73795
|
+
actionUrl: string().optional(),
|
|
73796
|
+
at: number()
|
|
73797
|
+
});
|
|
73600
73798
|
var RULE_BODY_ONLY = ["body"];
|
|
73601
73799
|
var RULE_TEXT = ["title", "body"];
|
|
73602
73800
|
var BATTERY = ["device-battery-low", "device-battery-normal"];
|
|
@@ -73606,6 +73804,11 @@ var TANK = [
|
|
|
73606
73804
|
"device-tank-full",
|
|
73607
73805
|
"device-tank-normal"
|
|
73608
73806
|
];
|
|
73807
|
+
var ALERT_EPISODE = [
|
|
73808
|
+
"alert-critical",
|
|
73809
|
+
"alert-error",
|
|
73810
|
+
"alert-critical-resolved"
|
|
73811
|
+
];
|
|
73609
73812
|
var UPDATES = [
|
|
73610
73813
|
"addon-update-available",
|
|
73611
73814
|
"server-update-available",
|
|
@@ -73798,14 +74001,14 @@ var STATE_SUMMARY_VARS = [
|
|
|
73798
74001
|
([...RULE_TEXT], [...CONSUMABLE]),
|
|
73799
74002
|
([...RULE_TEXT], [...TANK]),
|
|
73800
74003
|
[...RULE_TEXT],
|
|
73801
|
-
([...RULE_TEXT], [...UPDATES]),
|
|
73802
|
-
([...RULE_TEXT], [...UPDATES]),
|
|
73803
|
-
[...RULE_TEXT],
|
|
74004
|
+
([...RULE_TEXT], [...UPDATES, ...ALERT_EPISODE]),
|
|
74005
|
+
([...RULE_TEXT], [...UPDATES, ...ALERT_EPISODE]),
|
|
73804
74006
|
[...RULE_TEXT],
|
|
73805
74007
|
[...RULE_TEXT],
|
|
73806
74008
|
[...RULE_TEXT],
|
|
73807
74009
|
[...RULE_TEXT],
|
|
73808
74010
|
[...RULE_TEXT],
|
|
74011
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
73809
74012
|
[...RULE_TEXT],
|
|
73810
74013
|
[...RULE_TEXT],
|
|
73811
74014
|
[...RULE_TEXT],
|
|
@@ -73823,7 +74026,11 @@ var STATE_SUMMARY_VARS = [
|
|
|
73823
74026
|
[...RULE_TEXT],
|
|
73824
74027
|
[...RULE_TEXT],
|
|
73825
74028
|
[...RULE_TEXT],
|
|
73826
|
-
[...RULE_TEXT],
|
|
74029
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
74030
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
74031
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
74032
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
74033
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
73827
74034
|
[...RULE_TEXT],
|
|
73828
74035
|
[...RULE_TEXT],
|
|
73829
74036
|
[...RULE_TEXT],
|
|
@@ -39,7 +39,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
|
|
|
39
39
|
var __toCommonJS = (mod) => __hasOwnProp.call(mod, "module.exports") ? mod["module.exports"] : __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
|
40
40
|
var __require = /* @__PURE__ */ createRequire(import.meta.url);
|
|
41
41
|
//#endregion
|
|
42
|
-
//#region ../types/dist/event-category-
|
|
42
|
+
//#region ../types/dist/event-category-DOl51-Ij.mjs
|
|
43
43
|
var EventCategory = /* @__PURE__ */ function(EventCategory) {
|
|
44
44
|
EventCategory["SystemBoot"] = "system.boot";
|
|
45
45
|
EventCategory["SystemAddonsReady"] = "system.addons-ready";
|
|
@@ -118,9 +118,18 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
|
|
|
118
118
|
/**
|
|
119
119
|
* The node's one-shot runner boot check (D877): planned runners against the
|
|
120
120
|
* process service, `degraded` when any is failed, refused or missing. The
|
|
121
|
-
* alert centre turns it into one
|
|
121
|
+
* alert centre turns it into one critical alert.
|
|
122
122
|
*/
|
|
123
123
|
EventCategory["SystemRunnerCheck"] = "system.runner-check";
|
|
124
|
+
/**
|
|
125
|
+
* An alert EPISODE opened or closed, emitted by the alert centre for alerts
|
|
126
|
+
* of severity `critical` or `error` (`AlertEpisodePayload`). The alert
|
|
127
|
+
* centre sends no notification of its own: Notification Center turns this
|
|
128
|
+
* into the `alert-critical` / `alert-error` / `alert-critical-resolved`
|
|
129
|
+
* system-event kinds, and reconciles from the alerts store because a bus
|
|
130
|
+
* event may be dropped (D8, D11).
|
|
131
|
+
*/
|
|
132
|
+
EventCategory["AlertEpisode"] = "alert.episode";
|
|
124
133
|
EventCategory["AddonError"] = "addon.error";
|
|
125
134
|
EventCategory["AddonPageReady"] = "addon.page-ready";
|
|
126
135
|
EventCategory["AddonWidgetReady"] = "addon.widget-ready";
|
|
@@ -5578,7 +5587,7 @@ var ZodIssueCode = {
|
|
|
5578
5587
|
var ZodFirstPartyTypeKind;
|
|
5579
5588
|
ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
|
|
5580
5589
|
//#endregion
|
|
5581
|
-
//#region ../types/dist/sleep-
|
|
5590
|
+
//#region ../types/dist/sleep-BxjU_fJM.mjs
|
|
5582
5591
|
/**
|
|
5583
5592
|
* The audio chunk plane's byte format, and the ONE expansion from a coded
|
|
5584
5593
|
* window to float samples (D455).
|
|
@@ -13536,7 +13545,14 @@ var AlertSeveritySchema = _enum([
|
|
|
13536
13545
|
]);
|
|
13537
13546
|
var AlertActionSchema = object({
|
|
13538
13547
|
label: string(),
|
|
13539
|
-
href: string().optional()
|
|
13548
|
+
href: string().optional(),
|
|
13549
|
+
/**
|
|
13550
|
+
* How `href` is followed. Absent / `app`: an admin-ui route (client-side).
|
|
13551
|
+
* `server`: a route the HUB serves (an addon HTTP route such as an OAuth
|
|
13552
|
+
* start) — the browser must leave the SPA with a full navigation, because
|
|
13553
|
+
* the SPA has no such route and would bounce to the home page.
|
|
13554
|
+
*/
|
|
13555
|
+
navigation: _enum(["app", "server"]).optional()
|
|
13540
13556
|
});
|
|
13541
13557
|
var AlertStatusSchema = _enum([
|
|
13542
13558
|
"active",
|
|
@@ -41980,6 +41996,9 @@ var NcSystemEventKindSchema = _enum([
|
|
|
41980
41996
|
"server-updated",
|
|
41981
41997
|
"export-completed",
|
|
41982
41998
|
"backup-completed",
|
|
41999
|
+
"alert-critical",
|
|
42000
|
+
"alert-error",
|
|
42001
|
+
"alert-critical-resolved",
|
|
41983
42002
|
"camera-online",
|
|
41984
42003
|
"camera-offline",
|
|
41985
42004
|
"camera-disabled",
|
|
@@ -51012,7 +51031,10 @@ method(StorageMigrationInputSchema, StorageMigrationPlanSchema, { auth: "admin"
|
|
|
51012
51031
|
}), method(object({ jobId: string().optional() }), StorageMigrationJobSchema.nullable(), { auth: "admin" }), method(object({ jobId: string() }), object({ cancelled: boolean() }), {
|
|
51013
51032
|
kind: "mutation",
|
|
51014
51033
|
auth: "admin"
|
|
51015
|
-
}), method(object({}), array(StorageMigrationMoverSchema).readonly(), { auth: "admin" }), method(object({
|
|
51034
|
+
}), method(object({}), array(StorageMigrationMoverSchema).readonly(), { auth: "admin" }), method(object({ locationIds: array(string()).readonly() }), object({
|
|
51035
|
+
clear: boolean(),
|
|
51036
|
+
repointLocationId: string().optional()
|
|
51037
|
+
}), { auth: "admin" }), method(object({}), array(StorageMigrationResidueSchema).readonly(), { auth: "admin" }), method(StorageMigrationDrainInputSchema, object({ jobId: string() }), {
|
|
51016
51038
|
kind: "mutation",
|
|
51017
51039
|
auth: "admin"
|
|
51018
51040
|
}), method(StorageCleanupInputSchema, object({ jobId: string() }), {
|
|
@@ -54447,6 +54469,11 @@ object({
|
|
|
54447
54469
|
*
|
|
54448
54470
|
* `kind: 'poll'` — cloud REST APIs typically have no push channel; the
|
|
54449
54471
|
* provider refreshes the slice on an interval and eagerly after commands.
|
|
54472
|
+
*
|
|
54473
|
+
* UNKNOWN IS NOT OFF. Every field the appliance reports separately is
|
|
54474
|
+
* nullable: `null` means "not known right now" (the appliance has not said,
|
|
54475
|
+
* the link is down, or the description does not carry it) and is never
|
|
54476
|
+
* rendered or exported as `false` / `0`. `availability` says why.
|
|
54450
54477
|
*/
|
|
54451
54478
|
var DishwasherStateSchema = _enum([
|
|
54452
54479
|
"idle",
|
|
@@ -54456,112 +54483,227 @@ var DishwasherStateSchema = _enum([
|
|
|
54456
54483
|
"error",
|
|
54457
54484
|
"unavailable"
|
|
54458
54485
|
]);
|
|
54486
|
+
/**
|
|
54487
|
+
* The appliance's own operation state, uncollapsed. `state` above is the coarse
|
|
54488
|
+
* view for compact surfaces; this is what the appliance said.
|
|
54489
|
+
*/
|
|
54490
|
+
var DishwasherOperationStateSchema = _enum([
|
|
54491
|
+
"Inactive",
|
|
54492
|
+
"Ready",
|
|
54493
|
+
"DelayedStart",
|
|
54494
|
+
"Run",
|
|
54495
|
+
"Pause",
|
|
54496
|
+
"ActionRequired",
|
|
54497
|
+
"Finished",
|
|
54498
|
+
"Error",
|
|
54499
|
+
"Aborting"
|
|
54500
|
+
]);
|
|
54501
|
+
/**
|
|
54502
|
+
* Why fields may be `null`:
|
|
54503
|
+
* - `available` — the link is up and the description is loaded;
|
|
54504
|
+
* - `offline` — the local link is down (values are unknown, not last-known);
|
|
54505
|
+
* - `description-missing` — the link is up but the appliance's description could not
|
|
54506
|
+
* be loaded, so its values cannot be decoded.
|
|
54507
|
+
*/
|
|
54508
|
+
var DishwasherAvailabilitySchema = _enum([
|
|
54509
|
+
"available",
|
|
54510
|
+
"offline",
|
|
54511
|
+
"description-missing"
|
|
54512
|
+
]);
|
|
54459
54513
|
var DishwasherConsumableLevelSchema = _enum([
|
|
54460
54514
|
"ok",
|
|
54461
54515
|
"low",
|
|
54462
54516
|
"empty"
|
|
54463
54517
|
]);
|
|
54464
54518
|
object({
|
|
54519
|
+
availability: DishwasherAvailabilitySchema,
|
|
54520
|
+
/** Coarse state for compact surfaces; `unavailable` whenever the appliance state is not known. */
|
|
54465
54521
|
state: DishwasherStateSchema,
|
|
54466
|
-
/**
|
|
54522
|
+
/** The appliance's operation state as reported; null when not known. */
|
|
54523
|
+
operationState: DishwasherOperationStateSchema.nullable(),
|
|
54524
|
+
/** Feature key of the ACTIVE (running) program, or null when none runs / not known. */
|
|
54467
54525
|
program: string().nullable(),
|
|
54468
|
-
/**
|
|
54526
|
+
/** Feature key of the SELECTED program (what Start would run), or null when none / not known. */
|
|
54527
|
+
selectedProgram: string().nullable(),
|
|
54528
|
+
/** Feature keys of the programs the appliance currently offers — drives the UI selector. */
|
|
54469
54529
|
availablePrograms: array(string()),
|
|
54470
|
-
/**
|
|
54471
|
-
|
|
54530
|
+
/** Seconds remaining on the active cycle, or null when not running / not known. */
|
|
54531
|
+
remainingSeconds: number().int().nonnegative().nullable(),
|
|
54532
|
+
/** Seconds the delayed start is set to (time until the cycle starts), or null. */
|
|
54533
|
+
delayedStartSeconds: number().int().nonnegative().nullable(),
|
|
54472
54534
|
/** Cycle completion 0..100, or null when not applicable. */
|
|
54473
54535
|
progressPercent: number().min(0).max(100).nullable(),
|
|
54474
|
-
/** True when the door is reported open. */
|
|
54475
|
-
doorOpen: boolean(),
|
|
54476
|
-
/** True when
|
|
54477
|
-
|
|
54478
|
-
/**
|
|
54479
|
-
|
|
54536
|
+
/** True when the door is reported open; null when the door state is not known. */
|
|
54537
|
+
doorOpen: boolean().nullable(),
|
|
54538
|
+
/** True when the door is latched (locked) during a cycle; null when not reported. */
|
|
54539
|
+
doorLocked: boolean().nullable(),
|
|
54540
|
+
/** True when remote start is allowed (door closed, power on, etc.); null when not known. */
|
|
54541
|
+
remoteStartAllowed: boolean().nullable(),
|
|
54542
|
+
/** True when the appliance accepts remote control now; null when not known. */
|
|
54543
|
+
remoteControlActive: boolean().nullable(),
|
|
54544
|
+
/** True while somebody operates the appliance at its panel; null when not reported. */
|
|
54545
|
+
localControlActive: boolean().nullable(),
|
|
54546
|
+
/** Main power / switched-on state; null when not known. */
|
|
54547
|
+
powerOn: boolean().nullable(),
|
|
54548
|
+
/** The raw power state (`On`, `Off`, `Standby`, …); null when not known. */
|
|
54549
|
+
powerState: string().nullable(),
|
|
54480
54550
|
saltLevel: DishwasherConsumableLevelSchema.nullable(),
|
|
54481
54551
|
rinseAidLevel: DishwasherConsumableLevelSchema.nullable(),
|
|
54482
|
-
|
|
54483
|
-
|
|
54552
|
+
/** Option states: null when the appliance does not expose the option or has not said. */
|
|
54553
|
+
halfLoad: boolean().nullable(),
|
|
54554
|
+
hygienePlus: boolean().nullable(),
|
|
54484
54555
|
/** Extra dry option when the appliance exposes it. */
|
|
54485
|
-
extraDry: boolean(),
|
|
54556
|
+
extraDry: boolean().nullable(),
|
|
54486
54557
|
/** Intensive zone (lower basket) when the appliance exposes it. */
|
|
54487
|
-
intensiveZone: boolean(),
|
|
54558
|
+
intensiveZone: boolean().nullable(),
|
|
54488
54559
|
/** VarioSpeed / VarioSpeed+ when the appliance exposes it. */
|
|
54489
|
-
varioSpeedPlus: boolean(),
|
|
54490
|
-
/** Child lock (controls disabled on the appliance). */
|
|
54491
|
-
childLock: boolean(),
|
|
54560
|
+
varioSpeedPlus: boolean().nullable(),
|
|
54561
|
+
/** Child lock (controls disabled on the appliance); null when not known. */
|
|
54562
|
+
childLock: boolean().nullable(),
|
|
54563
|
+
/** Feature keys of the events currently raised (salt low, rinse aid low, program finished, …). */
|
|
54564
|
+
activeEvents: array(string()),
|
|
54565
|
+
/** Numeric error code when the appliance reports one; null otherwise. */
|
|
54492
54566
|
errorCode: number().nullable(),
|
|
54567
|
+
/** Name of the raised alert-level event while the appliance is in error; null otherwise. */
|
|
54493
54568
|
errorLabel: string().nullable(),
|
|
54569
|
+
/** Ms epoch of the last value received from the appliance; 0 = never. */
|
|
54494
54570
|
lastFetchedAt: number()
|
|
54495
54571
|
});
|
|
54496
|
-
|
|
54572
|
+
var DeviceIdSchema = number().int().nonnegative();
|
|
54573
|
+
/** A value a program option or setting can take. */
|
|
54574
|
+
var DishwasherValueSchema = union([
|
|
54575
|
+
boolean(),
|
|
54576
|
+
string(),
|
|
54577
|
+
number()
|
|
54578
|
+
]);
|
|
54579
|
+
var DishwasherAccessSchema = _enum([
|
|
54580
|
+
"none",
|
|
54581
|
+
"read",
|
|
54582
|
+
"readWrite",
|
|
54583
|
+
"writeOnly",
|
|
54584
|
+
"readStatic"
|
|
54585
|
+
]);
|
|
54586
|
+
/**
|
|
54587
|
+
* One option or setting the appliance declares, with the constraints its description
|
|
54588
|
+
* gives. A `readWrite` descriptor that is `available` is what `setOption` accepts.
|
|
54589
|
+
*/
|
|
54590
|
+
var DishwasherOptionDescriptorSchema = object({
|
|
54591
|
+
/** Feature key (`Dishcare.Dishwasher.Option.ExtraDry`). */
|
|
54592
|
+
key: string(),
|
|
54593
|
+
/** Last segment of the key, for display. */
|
|
54594
|
+
name: string(),
|
|
54595
|
+
type: _enum([
|
|
54596
|
+
"boolean",
|
|
54597
|
+
"number",
|
|
54598
|
+
"enum",
|
|
54599
|
+
"string"
|
|
54600
|
+
]),
|
|
54601
|
+
access: DishwasherAccessSchema,
|
|
54602
|
+
/** The appliance reports this entity as currently available. */
|
|
54603
|
+
available: boolean(),
|
|
54604
|
+
/** Unit the description declares for a number; null when it declares none. */
|
|
54605
|
+
unit: string().nullable(),
|
|
54606
|
+
min: number().nullable(),
|
|
54607
|
+
max: number().nullable(),
|
|
54608
|
+
step: number().nullable(),
|
|
54609
|
+
/** Allowed members of an enum; null for other types. */
|
|
54610
|
+
enumValues: array(string()).nullable(),
|
|
54611
|
+
defaultValue: DishwasherValueSchema.nullable()
|
|
54612
|
+
});
|
|
54613
|
+
var DishwasherProgramSchema = object({
|
|
54614
|
+
/** Feature key (`Dishcare.Dishwasher.Program.Eco50`) — what `setProgram` / `start` take. */
|
|
54615
|
+
key: string(),
|
|
54616
|
+
name: string(),
|
|
54617
|
+
/** The appliance currently offers this program. */
|
|
54618
|
+
available: boolean(),
|
|
54619
|
+
/** The options this program lists, with the program-level access / availability / default. */
|
|
54620
|
+
options: array(DishwasherOptionDescriptorSchema)
|
|
54621
|
+
});
|
|
54622
|
+
var DishwasherOptionsSchema = object({
|
|
54623
|
+
availability: DishwasherAvailabilitySchema,
|
|
54624
|
+
/** What the appliance can be told to do, from the commands its description declares. */
|
|
54625
|
+
supportsStart: boolean(),
|
|
54626
|
+
supportsPause: boolean(),
|
|
54627
|
+
supportsResume: boolean(),
|
|
54628
|
+
supportsStop: boolean(),
|
|
54629
|
+
supportsPower: boolean(),
|
|
54630
|
+
/** Every program the description lists, with its options. */
|
|
54631
|
+
programs: array(DishwasherProgramSchema),
|
|
54632
|
+
/** Every option and setting entity the description lists (programs reference these by key). */
|
|
54633
|
+
options: array(DishwasherOptionDescriptorSchema)
|
|
54634
|
+
});
|
|
54635
|
+
DeviceType.Dishwasher, method(object({
|
|
54636
|
+
deviceId: DeviceIdSchema,
|
|
54637
|
+
program: string().min(1).optional(),
|
|
54638
|
+
options: record(string(), DishwasherValueSchema).optional()
|
|
54639
|
+
}), _void(), {
|
|
54497
54640
|
kind: "mutation",
|
|
54498
54641
|
auth: "protected"
|
|
54499
|
-
}), method(object({ deviceId:
|
|
54642
|
+
}), method(object({ deviceId: DeviceIdSchema }), _void(), {
|
|
54500
54643
|
kind: "mutation",
|
|
54501
54644
|
auth: "protected"
|
|
54502
|
-
}), method(object({ deviceId:
|
|
54645
|
+
}), method(object({ deviceId: DeviceIdSchema }), _void(), {
|
|
54646
|
+
kind: "mutation",
|
|
54647
|
+
auth: "protected"
|
|
54648
|
+
}), method(object({ deviceId: DeviceIdSchema }), _void(), {
|
|
54503
54649
|
kind: "mutation",
|
|
54504
54650
|
auth: "protected"
|
|
54505
54651
|
}), method(object({
|
|
54506
|
-
deviceId:
|
|
54652
|
+
deviceId: DeviceIdSchema,
|
|
54507
54653
|
program: string().min(1)
|
|
54508
54654
|
}), _void(), {
|
|
54509
54655
|
kind: "mutation",
|
|
54510
54656
|
auth: "protected"
|
|
54511
54657
|
}), method(object({
|
|
54512
|
-
deviceId:
|
|
54658
|
+
deviceId: DeviceIdSchema,
|
|
54513
54659
|
on: boolean()
|
|
54514
54660
|
}), _void(), {
|
|
54515
54661
|
kind: "mutation",
|
|
54516
54662
|
auth: "protected"
|
|
54517
54663
|
}), method(object({
|
|
54518
|
-
deviceId:
|
|
54664
|
+
deviceId: DeviceIdSchema,
|
|
54519
54665
|
on: boolean()
|
|
54520
54666
|
}), _void(), {
|
|
54521
54667
|
kind: "mutation",
|
|
54522
54668
|
auth: "protected"
|
|
54523
54669
|
}), method(object({
|
|
54524
|
-
deviceId:
|
|
54670
|
+
deviceId: DeviceIdSchema,
|
|
54525
54671
|
on: boolean()
|
|
54526
54672
|
}), _void(), {
|
|
54527
54673
|
kind: "mutation",
|
|
54528
54674
|
auth: "protected"
|
|
54529
54675
|
}), method(object({
|
|
54530
|
-
deviceId:
|
|
54676
|
+
deviceId: DeviceIdSchema,
|
|
54531
54677
|
on: boolean()
|
|
54532
54678
|
}), _void(), {
|
|
54533
54679
|
kind: "mutation",
|
|
54534
54680
|
auth: "protected"
|
|
54535
54681
|
}), method(object({
|
|
54536
|
-
deviceId:
|
|
54682
|
+
deviceId: DeviceIdSchema,
|
|
54537
54683
|
on: boolean()
|
|
54538
54684
|
}), _void(), {
|
|
54539
54685
|
kind: "mutation",
|
|
54540
54686
|
auth: "protected"
|
|
54541
54687
|
}), method(object({
|
|
54542
|
-
deviceId:
|
|
54688
|
+
deviceId: DeviceIdSchema,
|
|
54543
54689
|
on: boolean()
|
|
54544
54690
|
}), _void(), {
|
|
54545
54691
|
kind: "mutation",
|
|
54546
54692
|
auth: "protected"
|
|
54547
54693
|
}), method(object({
|
|
54548
|
-
deviceId:
|
|
54694
|
+
deviceId: DeviceIdSchema,
|
|
54549
54695
|
on: boolean()
|
|
54550
54696
|
}), _void(), {
|
|
54551
54697
|
kind: "mutation",
|
|
54552
54698
|
auth: "protected"
|
|
54553
54699
|
}), method(object({
|
|
54554
|
-
deviceId:
|
|
54700
|
+
deviceId: DeviceIdSchema,
|
|
54555
54701
|
key: string().min(1),
|
|
54556
|
-
value:
|
|
54557
|
-
boolean(),
|
|
54558
|
-
string(),
|
|
54559
|
-
number()
|
|
54560
|
-
])
|
|
54702
|
+
value: DishwasherValueSchema
|
|
54561
54703
|
}), _void(), {
|
|
54562
54704
|
kind: "mutation",
|
|
54563
54705
|
auth: "protected"
|
|
54564
|
-
});
|
|
54706
|
+
}), method(object({ deviceId: DeviceIdSchema }), DishwasherOptionsSchema, { auth: "protected" });
|
|
54565
54707
|
object({
|
|
54566
54708
|
/** Ms epoch of the last press. null = never observed since this provider started. */
|
|
54567
54709
|
lastPressedAt: number().nullable(),
|
|
@@ -64621,6 +64763,12 @@ Object.freeze({
|
|
|
64621
64763
|
addonId: null,
|
|
64622
64764
|
access: "view"
|
|
64623
64765
|
},
|
|
64766
|
+
"dishwasher.getOptions": {
|
|
64767
|
+
capName: "dishwasher",
|
|
64768
|
+
capScope: "device",
|
|
64769
|
+
addonId: null,
|
|
64770
|
+
access: "view"
|
|
64771
|
+
},
|
|
64624
64772
|
"dishwasher.getStatus": {
|
|
64625
64773
|
capName: "dishwasher",
|
|
64626
64774
|
capScope: "device",
|
|
@@ -64633,6 +64781,12 @@ Object.freeze({
|
|
|
64633
64781
|
addonId: null,
|
|
64634
64782
|
access: "create"
|
|
64635
64783
|
},
|
|
64784
|
+
"dishwasher.resume": {
|
|
64785
|
+
capName: "dishwasher",
|
|
64786
|
+
capScope: "device",
|
|
64787
|
+
addonId: null,
|
|
64788
|
+
access: "create"
|
|
64789
|
+
},
|
|
64636
64790
|
"dishwasher.setChildLock": {
|
|
64637
64791
|
capName: "dishwasher",
|
|
64638
64792
|
capScope: "device",
|
|
@@ -69133,6 +69287,12 @@ Object.freeze({
|
|
|
69133
69287
|
addonId: null,
|
|
69134
69288
|
access: "view"
|
|
69135
69289
|
},
|
|
69290
|
+
"storageMigration.moverClearance": {
|
|
69291
|
+
capName: "storage-migration",
|
|
69292
|
+
capScope: "system",
|
|
69293
|
+
addonId: null,
|
|
69294
|
+
access: "view"
|
|
69295
|
+
},
|
|
69136
69296
|
"storageMigration.movers": {
|
|
69137
69297
|
capName: "storage-migration",
|
|
69138
69298
|
capScope: "system",
|
|
@@ -71326,6 +71486,11 @@ Object.freeze({
|
|
|
71326
71486
|
form: "single",
|
|
71327
71487
|
optional: false
|
|
71328
71488
|
}],
|
|
71489
|
+
"dishwasher.getOptions": [{
|
|
71490
|
+
name: "deviceId",
|
|
71491
|
+
form: "single",
|
|
71492
|
+
optional: false
|
|
71493
|
+
}],
|
|
71329
71494
|
"dishwasher.getStatus": [{
|
|
71330
71495
|
name: "deviceId",
|
|
71331
71496
|
form: "single",
|
|
@@ -71336,6 +71501,11 @@ Object.freeze({
|
|
|
71336
71501
|
form: "single",
|
|
71337
71502
|
optional: false
|
|
71338
71503
|
}],
|
|
71504
|
+
"dishwasher.resume": [{
|
|
71505
|
+
name: "deviceId",
|
|
71506
|
+
form: "single",
|
|
71507
|
+
optional: false
|
|
71508
|
+
}],
|
|
71339
71509
|
"dishwasher.setChildLock": [{
|
|
71340
71510
|
name: "deviceId",
|
|
71341
71511
|
form: "single",
|
|
@@ -73422,6 +73592,9 @@ new Map(Object.entries({
|
|
|
73422
73592
|
"wrapper-update-available": "system",
|
|
73423
73593
|
"backup-completed": "system",
|
|
73424
73594
|
"export-completed": "system",
|
|
73595
|
+
"alert-critical": "system",
|
|
73596
|
+
"alert-error": "system",
|
|
73597
|
+
"alert-critical-resolved": "system",
|
|
73425
73598
|
"storage-location-low": "system",
|
|
73426
73599
|
"storage-location-critical": "system",
|
|
73427
73600
|
"storage-location-ok": "system",
|
|
@@ -73546,6 +73719,16 @@ var NC_SYSTEM_EVENT_KIND_GROUP_SPECS = [
|
|
|
73546
73719
|
"storage-location-ok"
|
|
73547
73720
|
]
|
|
73548
73721
|
},
|
|
73722
|
+
{
|
|
73723
|
+
id: "alerts",
|
|
73724
|
+
family: "system",
|
|
73725
|
+
label: "Alerts",
|
|
73726
|
+
kinds: [
|
|
73727
|
+
"alert-critical",
|
|
73728
|
+
"alert-error",
|
|
73729
|
+
"alert-critical-resolved"
|
|
73730
|
+
]
|
|
73731
|
+
},
|
|
73549
73732
|
{
|
|
73550
73733
|
id: "alarm",
|
|
73551
73734
|
family: "alarm",
|
|
@@ -73590,6 +73773,21 @@ var NC_SENSOR_RAISED_FIELD_BY_KIND = Object.freeze(Object.fromEntries(Object.ent
|
|
|
73590
73773
|
return [[descriptor.kind, field]];
|
|
73591
73774
|
})));
|
|
73592
73775
|
Object.freeze(Object.keys(NC_SENSOR_RAISED_FIELD_BY_KIND));
|
|
73776
|
+
object({
|
|
73777
|
+
phase: _enum(["raised", "resolved"]),
|
|
73778
|
+
episodeId: string().min(1),
|
|
73779
|
+
alertId: string().min(1),
|
|
73780
|
+
severity: AlertSeveritySchema,
|
|
73781
|
+
category: string(),
|
|
73782
|
+
title: string(),
|
|
73783
|
+
message: string(),
|
|
73784
|
+
sourceType: string().optional(),
|
|
73785
|
+
sourceId: string().optional(),
|
|
73786
|
+
nodeId: string().optional(),
|
|
73787
|
+
/** The alert's own action link (where the operator acts on it), when it has one. */
|
|
73788
|
+
actionUrl: string().optional(),
|
|
73789
|
+
at: number()
|
|
73790
|
+
});
|
|
73593
73791
|
var RULE_BODY_ONLY = ["body"];
|
|
73594
73792
|
var RULE_TEXT = ["title", "body"];
|
|
73595
73793
|
var BATTERY = ["device-battery-low", "device-battery-normal"];
|
|
@@ -73599,6 +73797,11 @@ var TANK = [
|
|
|
73599
73797
|
"device-tank-full",
|
|
73600
73798
|
"device-tank-normal"
|
|
73601
73799
|
];
|
|
73800
|
+
var ALERT_EPISODE = [
|
|
73801
|
+
"alert-critical",
|
|
73802
|
+
"alert-error",
|
|
73803
|
+
"alert-critical-resolved"
|
|
73804
|
+
];
|
|
73602
73805
|
var UPDATES = [
|
|
73603
73806
|
"addon-update-available",
|
|
73604
73807
|
"server-update-available",
|
|
@@ -73791,14 +73994,14 @@ var STATE_SUMMARY_VARS = [
|
|
|
73791
73994
|
([...RULE_TEXT], [...CONSUMABLE]),
|
|
73792
73995
|
([...RULE_TEXT], [...TANK]),
|
|
73793
73996
|
[...RULE_TEXT],
|
|
73794
|
-
([...RULE_TEXT], [...UPDATES]),
|
|
73795
|
-
([...RULE_TEXT], [...UPDATES]),
|
|
73796
|
-
[...RULE_TEXT],
|
|
73997
|
+
([...RULE_TEXT], [...UPDATES, ...ALERT_EPISODE]),
|
|
73998
|
+
([...RULE_TEXT], [...UPDATES, ...ALERT_EPISODE]),
|
|
73797
73999
|
[...RULE_TEXT],
|
|
73798
74000
|
[...RULE_TEXT],
|
|
73799
74001
|
[...RULE_TEXT],
|
|
73800
74002
|
[...RULE_TEXT],
|
|
73801
74003
|
[...RULE_TEXT],
|
|
74004
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
73802
74005
|
[...RULE_TEXT],
|
|
73803
74006
|
[...RULE_TEXT],
|
|
73804
74007
|
[...RULE_TEXT],
|
|
@@ -73816,7 +74019,11 @@ var STATE_SUMMARY_VARS = [
|
|
|
73816
74019
|
[...RULE_TEXT],
|
|
73817
74020
|
[...RULE_TEXT],
|
|
73818
74021
|
[...RULE_TEXT],
|
|
73819
|
-
[...RULE_TEXT],
|
|
74022
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
74023
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
74024
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
74025
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
74026
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
73820
74027
|
[...RULE_TEXT],
|
|
73821
74028
|
[...RULE_TEXT],
|
|
73822
74029
|
[...RULE_TEXT],
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@camstack/addon-mqtt-broker",
|
|
3
|
-
"version": "1.2.
|
|
3
|
+
"version": "1.2.128",
|
|
4
4
|
"description": "MQTT broker registry addon for CamStack — manages external broker entries + an optional embedded aedes broker. Consumers spin up their own `mqtt.js` clients via the `mqtt-broker` cap.",
|
|
5
5
|
"keywords": [
|
|
6
6
|
"camstack",
|