@camstack/addon-decoder-nodeav 1.2.124 → 1.2.125
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/index.js +251 -44
- package/dist/index.mjs +251 -44
- package/package.json +1 -1
package/dist/index.js
CHANGED
|
@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
|
|
|
3
3
|
[Symbol.toStringTag]: { value: "Module" }
|
|
4
4
|
});
|
|
5
5
|
let node_crypto = require("node:crypto");
|
|
6
|
-
//#region ../types/dist/event-category-
|
|
6
|
+
//#region ../types/dist/event-category-DOl51-Ij.mjs
|
|
7
7
|
var EventCategory = /* @__PURE__ */ function(EventCategory) {
|
|
8
8
|
EventCategory["SystemBoot"] = "system.boot";
|
|
9
9
|
EventCategory["SystemAddonsReady"] = "system.addons-ready";
|
|
@@ -82,9 +82,18 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
|
|
|
82
82
|
/**
|
|
83
83
|
* The node's one-shot runner boot check (D877): planned runners against the
|
|
84
84
|
* process service, `degraded` when any is failed, refused or missing. The
|
|
85
|
-
* alert centre turns it into one
|
|
85
|
+
* alert centre turns it into one critical alert.
|
|
86
86
|
*/
|
|
87
87
|
EventCategory["SystemRunnerCheck"] = "system.runner-check";
|
|
88
|
+
/**
|
|
89
|
+
* An alert EPISODE opened or closed, emitted by the alert centre for alerts
|
|
90
|
+
* of severity `critical` or `error` (`AlertEpisodePayload`). The alert
|
|
91
|
+
* centre sends no notification of its own: Notification Center turns this
|
|
92
|
+
* into the `alert-critical` / `alert-error` / `alert-critical-resolved`
|
|
93
|
+
* system-event kinds, and reconciles from the alerts store because a bus
|
|
94
|
+
* event may be dropped (D8, D11).
|
|
95
|
+
*/
|
|
96
|
+
EventCategory["AlertEpisode"] = "alert.episode";
|
|
88
97
|
EventCategory["AddonError"] = "addon.error";
|
|
89
98
|
EventCategory["AddonPageReady"] = "addon.page-ready";
|
|
90
99
|
EventCategory["AddonWidgetReady"] = "addon.widget-ready";
|
|
@@ -5409,7 +5418,7 @@ var ZodIssueCode = {
|
|
|
5409
5418
|
var ZodFirstPartyTypeKind;
|
|
5410
5419
|
ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
|
|
5411
5420
|
//#endregion
|
|
5412
|
-
//#region ../types/dist/sleep-
|
|
5421
|
+
//#region ../types/dist/sleep-BxjU_fJM.mjs
|
|
5413
5422
|
/**
|
|
5414
5423
|
* The audio chunk plane's byte format, and the ONE expansion from a coded
|
|
5415
5424
|
* window to float samples (D455).
|
|
@@ -13101,7 +13110,14 @@ var AlertSeveritySchema = _enum([
|
|
|
13101
13110
|
]);
|
|
13102
13111
|
var AlertActionSchema = object({
|
|
13103
13112
|
label: string(),
|
|
13104
|
-
href: string().optional()
|
|
13113
|
+
href: string().optional(),
|
|
13114
|
+
/**
|
|
13115
|
+
* How `href` is followed. Absent / `app`: an admin-ui route (client-side).
|
|
13116
|
+
* `server`: a route the HUB serves (an addon HTTP route such as an OAuth
|
|
13117
|
+
* start) — the browser must leave the SPA with a full navigation, because
|
|
13118
|
+
* the SPA has no such route and would bounce to the home page.
|
|
13119
|
+
*/
|
|
13120
|
+
navigation: _enum(["app", "server"]).optional()
|
|
13105
13121
|
});
|
|
13106
13122
|
var AlertStatusSchema = _enum([
|
|
13107
13123
|
"active",
|
|
@@ -41595,6 +41611,9 @@ var NcSystemEventKindSchema = _enum([
|
|
|
41595
41611
|
"server-updated",
|
|
41596
41612
|
"export-completed",
|
|
41597
41613
|
"backup-completed",
|
|
41614
|
+
"alert-critical",
|
|
41615
|
+
"alert-error",
|
|
41616
|
+
"alert-critical-resolved",
|
|
41598
41617
|
"camera-online",
|
|
41599
41618
|
"camera-offline",
|
|
41600
41619
|
"camera-disabled",
|
|
@@ -50627,7 +50646,10 @@ method(StorageMigrationInputSchema, StorageMigrationPlanSchema, { auth: "admin"
|
|
|
50627
50646
|
}), method(object({ jobId: string().optional() }), StorageMigrationJobSchema.nullable(), { auth: "admin" }), method(object({ jobId: string() }), object({ cancelled: boolean() }), {
|
|
50628
50647
|
kind: "mutation",
|
|
50629
50648
|
auth: "admin"
|
|
50630
|
-
}), method(object({}), array(StorageMigrationMoverSchema).readonly(), { auth: "admin" }), method(object({
|
|
50649
|
+
}), method(object({}), array(StorageMigrationMoverSchema).readonly(), { auth: "admin" }), method(object({ locationIds: array(string()).readonly() }), object({
|
|
50650
|
+
clear: boolean(),
|
|
50651
|
+
repointLocationId: string().optional()
|
|
50652
|
+
}), { auth: "admin" }), method(object({}), array(StorageMigrationResidueSchema).readonly(), { auth: "admin" }), method(StorageMigrationDrainInputSchema, object({ jobId: string() }), {
|
|
50631
50653
|
kind: "mutation",
|
|
50632
50654
|
auth: "admin"
|
|
50633
50655
|
}), method(StorageCleanupInputSchema, object({ jobId: string() }), {
|
|
@@ -54062,6 +54084,11 @@ object({
|
|
|
54062
54084
|
*
|
|
54063
54085
|
* `kind: 'poll'` — cloud REST APIs typically have no push channel; the
|
|
54064
54086
|
* provider refreshes the slice on an interval and eagerly after commands.
|
|
54087
|
+
*
|
|
54088
|
+
* UNKNOWN IS NOT OFF. Every field the appliance reports separately is
|
|
54089
|
+
* nullable: `null` means "not known right now" (the appliance has not said,
|
|
54090
|
+
* the link is down, or the description does not carry it) and is never
|
|
54091
|
+
* rendered or exported as `false` / `0`. `availability` says why.
|
|
54065
54092
|
*/
|
|
54066
54093
|
var DishwasherStateSchema = _enum([
|
|
54067
54094
|
"idle",
|
|
@@ -54071,112 +54098,227 @@ var DishwasherStateSchema = _enum([
|
|
|
54071
54098
|
"error",
|
|
54072
54099
|
"unavailable"
|
|
54073
54100
|
]);
|
|
54101
|
+
/**
|
|
54102
|
+
* The appliance's own operation state, uncollapsed. `state` above is the coarse
|
|
54103
|
+
* view for compact surfaces; this is what the appliance said.
|
|
54104
|
+
*/
|
|
54105
|
+
var DishwasherOperationStateSchema = _enum([
|
|
54106
|
+
"Inactive",
|
|
54107
|
+
"Ready",
|
|
54108
|
+
"DelayedStart",
|
|
54109
|
+
"Run",
|
|
54110
|
+
"Pause",
|
|
54111
|
+
"ActionRequired",
|
|
54112
|
+
"Finished",
|
|
54113
|
+
"Error",
|
|
54114
|
+
"Aborting"
|
|
54115
|
+
]);
|
|
54116
|
+
/**
|
|
54117
|
+
* Why fields may be `null`:
|
|
54118
|
+
* - `available` — the link is up and the description is loaded;
|
|
54119
|
+
* - `offline` — the local link is down (values are unknown, not last-known);
|
|
54120
|
+
* - `description-missing` — the link is up but the appliance's description could not
|
|
54121
|
+
* be loaded, so its values cannot be decoded.
|
|
54122
|
+
*/
|
|
54123
|
+
var DishwasherAvailabilitySchema = _enum([
|
|
54124
|
+
"available",
|
|
54125
|
+
"offline",
|
|
54126
|
+
"description-missing"
|
|
54127
|
+
]);
|
|
54074
54128
|
var DishwasherConsumableLevelSchema = _enum([
|
|
54075
54129
|
"ok",
|
|
54076
54130
|
"low",
|
|
54077
54131
|
"empty"
|
|
54078
54132
|
]);
|
|
54079
54133
|
object({
|
|
54134
|
+
availability: DishwasherAvailabilitySchema,
|
|
54135
|
+
/** Coarse state for compact surfaces; `unavailable` whenever the appliance state is not known. */
|
|
54080
54136
|
state: DishwasherStateSchema,
|
|
54081
|
-
/**
|
|
54137
|
+
/** The appliance's operation state as reported; null when not known. */
|
|
54138
|
+
operationState: DishwasherOperationStateSchema.nullable(),
|
|
54139
|
+
/** Feature key of the ACTIVE (running) program, or null when none runs / not known. */
|
|
54082
54140
|
program: string().nullable(),
|
|
54083
|
-
/**
|
|
54141
|
+
/** Feature key of the SELECTED program (what Start would run), or null when none / not known. */
|
|
54142
|
+
selectedProgram: string().nullable(),
|
|
54143
|
+
/** Feature keys of the programs the appliance currently offers — drives the UI selector. */
|
|
54084
54144
|
availablePrograms: array(string()),
|
|
54085
|
-
/**
|
|
54086
|
-
|
|
54145
|
+
/** Seconds remaining on the active cycle, or null when not running / not known. */
|
|
54146
|
+
remainingSeconds: number().int().nonnegative().nullable(),
|
|
54147
|
+
/** Seconds the delayed start is set to (time until the cycle starts), or null. */
|
|
54148
|
+
delayedStartSeconds: number().int().nonnegative().nullable(),
|
|
54087
54149
|
/** Cycle completion 0..100, or null when not applicable. */
|
|
54088
54150
|
progressPercent: number().min(0).max(100).nullable(),
|
|
54089
|
-
/** True when the door is reported open. */
|
|
54090
|
-
doorOpen: boolean(),
|
|
54091
|
-
/** True when
|
|
54092
|
-
|
|
54093
|
-
/**
|
|
54094
|
-
|
|
54151
|
+
/** True when the door is reported open; null when the door state is not known. */
|
|
54152
|
+
doorOpen: boolean().nullable(),
|
|
54153
|
+
/** True when the door is latched (locked) during a cycle; null when not reported. */
|
|
54154
|
+
doorLocked: boolean().nullable(),
|
|
54155
|
+
/** True when remote start is allowed (door closed, power on, etc.); null when not known. */
|
|
54156
|
+
remoteStartAllowed: boolean().nullable(),
|
|
54157
|
+
/** True when the appliance accepts remote control now; null when not known. */
|
|
54158
|
+
remoteControlActive: boolean().nullable(),
|
|
54159
|
+
/** True while somebody operates the appliance at its panel; null when not reported. */
|
|
54160
|
+
localControlActive: boolean().nullable(),
|
|
54161
|
+
/** Main power / switched-on state; null when not known. */
|
|
54162
|
+
powerOn: boolean().nullable(),
|
|
54163
|
+
/** The raw power state (`On`, `Off`, `Standby`, …); null when not known. */
|
|
54164
|
+
powerState: string().nullable(),
|
|
54095
54165
|
saltLevel: DishwasherConsumableLevelSchema.nullable(),
|
|
54096
54166
|
rinseAidLevel: DishwasherConsumableLevelSchema.nullable(),
|
|
54097
|
-
|
|
54098
|
-
|
|
54167
|
+
/** Option states: null when the appliance does not expose the option or has not said. */
|
|
54168
|
+
halfLoad: boolean().nullable(),
|
|
54169
|
+
hygienePlus: boolean().nullable(),
|
|
54099
54170
|
/** Extra dry option when the appliance exposes it. */
|
|
54100
|
-
extraDry: boolean(),
|
|
54171
|
+
extraDry: boolean().nullable(),
|
|
54101
54172
|
/** Intensive zone (lower basket) when the appliance exposes it. */
|
|
54102
|
-
intensiveZone: boolean(),
|
|
54173
|
+
intensiveZone: boolean().nullable(),
|
|
54103
54174
|
/** VarioSpeed / VarioSpeed+ when the appliance exposes it. */
|
|
54104
|
-
varioSpeedPlus: boolean(),
|
|
54105
|
-
/** Child lock (controls disabled on the appliance). */
|
|
54106
|
-
childLock: boolean(),
|
|
54175
|
+
varioSpeedPlus: boolean().nullable(),
|
|
54176
|
+
/** Child lock (controls disabled on the appliance); null when not known. */
|
|
54177
|
+
childLock: boolean().nullable(),
|
|
54178
|
+
/** Feature keys of the events currently raised (salt low, rinse aid low, program finished, …). */
|
|
54179
|
+
activeEvents: array(string()),
|
|
54180
|
+
/** Numeric error code when the appliance reports one; null otherwise. */
|
|
54107
54181
|
errorCode: number().nullable(),
|
|
54182
|
+
/** Name of the raised alert-level event while the appliance is in error; null otherwise. */
|
|
54108
54183
|
errorLabel: string().nullable(),
|
|
54184
|
+
/** Ms epoch of the last value received from the appliance; 0 = never. */
|
|
54109
54185
|
lastFetchedAt: number()
|
|
54110
54186
|
});
|
|
54111
|
-
|
|
54187
|
+
var DeviceIdSchema = number().int().nonnegative();
|
|
54188
|
+
/** A value a program option or setting can take. */
|
|
54189
|
+
var DishwasherValueSchema = union([
|
|
54190
|
+
boolean(),
|
|
54191
|
+
string(),
|
|
54192
|
+
number()
|
|
54193
|
+
]);
|
|
54194
|
+
var DishwasherAccessSchema = _enum([
|
|
54195
|
+
"none",
|
|
54196
|
+
"read",
|
|
54197
|
+
"readWrite",
|
|
54198
|
+
"writeOnly",
|
|
54199
|
+
"readStatic"
|
|
54200
|
+
]);
|
|
54201
|
+
/**
|
|
54202
|
+
* One option or setting the appliance declares, with the constraints its description
|
|
54203
|
+
* gives. A `readWrite` descriptor that is `available` is what `setOption` accepts.
|
|
54204
|
+
*/
|
|
54205
|
+
var DishwasherOptionDescriptorSchema = object({
|
|
54206
|
+
/** Feature key (`Dishcare.Dishwasher.Option.ExtraDry`). */
|
|
54207
|
+
key: string(),
|
|
54208
|
+
/** Last segment of the key, for display. */
|
|
54209
|
+
name: string(),
|
|
54210
|
+
type: _enum([
|
|
54211
|
+
"boolean",
|
|
54212
|
+
"number",
|
|
54213
|
+
"enum",
|
|
54214
|
+
"string"
|
|
54215
|
+
]),
|
|
54216
|
+
access: DishwasherAccessSchema,
|
|
54217
|
+
/** The appliance reports this entity as currently available. */
|
|
54218
|
+
available: boolean(),
|
|
54219
|
+
/** Unit the description declares for a number; null when it declares none. */
|
|
54220
|
+
unit: string().nullable(),
|
|
54221
|
+
min: number().nullable(),
|
|
54222
|
+
max: number().nullable(),
|
|
54223
|
+
step: number().nullable(),
|
|
54224
|
+
/** Allowed members of an enum; null for other types. */
|
|
54225
|
+
enumValues: array(string()).nullable(),
|
|
54226
|
+
defaultValue: DishwasherValueSchema.nullable()
|
|
54227
|
+
});
|
|
54228
|
+
var DishwasherProgramSchema = object({
|
|
54229
|
+
/** Feature key (`Dishcare.Dishwasher.Program.Eco50`) — what `setProgram` / `start` take. */
|
|
54230
|
+
key: string(),
|
|
54231
|
+
name: string(),
|
|
54232
|
+
/** The appliance currently offers this program. */
|
|
54233
|
+
available: boolean(),
|
|
54234
|
+
/** The options this program lists, with the program-level access / availability / default. */
|
|
54235
|
+
options: array(DishwasherOptionDescriptorSchema)
|
|
54236
|
+
});
|
|
54237
|
+
var DishwasherOptionsSchema = object({
|
|
54238
|
+
availability: DishwasherAvailabilitySchema,
|
|
54239
|
+
/** What the appliance can be told to do, from the commands its description declares. */
|
|
54240
|
+
supportsStart: boolean(),
|
|
54241
|
+
supportsPause: boolean(),
|
|
54242
|
+
supportsResume: boolean(),
|
|
54243
|
+
supportsStop: boolean(),
|
|
54244
|
+
supportsPower: boolean(),
|
|
54245
|
+
/** Every program the description lists, with its options. */
|
|
54246
|
+
programs: array(DishwasherProgramSchema),
|
|
54247
|
+
/** Every option and setting entity the description lists (programs reference these by key). */
|
|
54248
|
+
options: array(DishwasherOptionDescriptorSchema)
|
|
54249
|
+
});
|
|
54250
|
+
DeviceType.Dishwasher, method(object({
|
|
54251
|
+
deviceId: DeviceIdSchema,
|
|
54252
|
+
program: string().min(1).optional(),
|
|
54253
|
+
options: record(string(), DishwasherValueSchema).optional()
|
|
54254
|
+
}), _void(), {
|
|
54112
54255
|
kind: "mutation",
|
|
54113
54256
|
auth: "protected"
|
|
54114
|
-
}), method(object({ deviceId:
|
|
54257
|
+
}), method(object({ deviceId: DeviceIdSchema }), _void(), {
|
|
54115
54258
|
kind: "mutation",
|
|
54116
54259
|
auth: "protected"
|
|
54117
|
-
}), method(object({ deviceId:
|
|
54260
|
+
}), method(object({ deviceId: DeviceIdSchema }), _void(), {
|
|
54261
|
+
kind: "mutation",
|
|
54262
|
+
auth: "protected"
|
|
54263
|
+
}), method(object({ deviceId: DeviceIdSchema }), _void(), {
|
|
54118
54264
|
kind: "mutation",
|
|
54119
54265
|
auth: "protected"
|
|
54120
54266
|
}), method(object({
|
|
54121
|
-
deviceId:
|
|
54267
|
+
deviceId: DeviceIdSchema,
|
|
54122
54268
|
program: string().min(1)
|
|
54123
54269
|
}), _void(), {
|
|
54124
54270
|
kind: "mutation",
|
|
54125
54271
|
auth: "protected"
|
|
54126
54272
|
}), method(object({
|
|
54127
|
-
deviceId:
|
|
54273
|
+
deviceId: DeviceIdSchema,
|
|
54128
54274
|
on: boolean()
|
|
54129
54275
|
}), _void(), {
|
|
54130
54276
|
kind: "mutation",
|
|
54131
54277
|
auth: "protected"
|
|
54132
54278
|
}), method(object({
|
|
54133
|
-
deviceId:
|
|
54279
|
+
deviceId: DeviceIdSchema,
|
|
54134
54280
|
on: boolean()
|
|
54135
54281
|
}), _void(), {
|
|
54136
54282
|
kind: "mutation",
|
|
54137
54283
|
auth: "protected"
|
|
54138
54284
|
}), method(object({
|
|
54139
|
-
deviceId:
|
|
54285
|
+
deviceId: DeviceIdSchema,
|
|
54140
54286
|
on: boolean()
|
|
54141
54287
|
}), _void(), {
|
|
54142
54288
|
kind: "mutation",
|
|
54143
54289
|
auth: "protected"
|
|
54144
54290
|
}), method(object({
|
|
54145
|
-
deviceId:
|
|
54291
|
+
deviceId: DeviceIdSchema,
|
|
54146
54292
|
on: boolean()
|
|
54147
54293
|
}), _void(), {
|
|
54148
54294
|
kind: "mutation",
|
|
54149
54295
|
auth: "protected"
|
|
54150
54296
|
}), method(object({
|
|
54151
|
-
deviceId:
|
|
54297
|
+
deviceId: DeviceIdSchema,
|
|
54152
54298
|
on: boolean()
|
|
54153
54299
|
}), _void(), {
|
|
54154
54300
|
kind: "mutation",
|
|
54155
54301
|
auth: "protected"
|
|
54156
54302
|
}), method(object({
|
|
54157
|
-
deviceId:
|
|
54303
|
+
deviceId: DeviceIdSchema,
|
|
54158
54304
|
on: boolean()
|
|
54159
54305
|
}), _void(), {
|
|
54160
54306
|
kind: "mutation",
|
|
54161
54307
|
auth: "protected"
|
|
54162
54308
|
}), method(object({
|
|
54163
|
-
deviceId:
|
|
54309
|
+
deviceId: DeviceIdSchema,
|
|
54164
54310
|
on: boolean()
|
|
54165
54311
|
}), _void(), {
|
|
54166
54312
|
kind: "mutation",
|
|
54167
54313
|
auth: "protected"
|
|
54168
54314
|
}), method(object({
|
|
54169
|
-
deviceId:
|
|
54315
|
+
deviceId: DeviceIdSchema,
|
|
54170
54316
|
key: string().min(1),
|
|
54171
|
-
value:
|
|
54172
|
-
boolean(),
|
|
54173
|
-
string(),
|
|
54174
|
-
number()
|
|
54175
|
-
])
|
|
54317
|
+
value: DishwasherValueSchema
|
|
54176
54318
|
}), _void(), {
|
|
54177
54319
|
kind: "mutation",
|
|
54178
54320
|
auth: "protected"
|
|
54179
|
-
});
|
|
54321
|
+
}), method(object({ deviceId: DeviceIdSchema }), DishwasherOptionsSchema, { auth: "protected" });
|
|
54180
54322
|
object({
|
|
54181
54323
|
/** Ms epoch of the last press. null = never observed since this provider started. */
|
|
54182
54324
|
lastPressedAt: number().nullable(),
|
|
@@ -64236,6 +64378,12 @@ Object.freeze({
|
|
|
64236
64378
|
addonId: null,
|
|
64237
64379
|
access: "view"
|
|
64238
64380
|
},
|
|
64381
|
+
"dishwasher.getOptions": {
|
|
64382
|
+
capName: "dishwasher",
|
|
64383
|
+
capScope: "device",
|
|
64384
|
+
addonId: null,
|
|
64385
|
+
access: "view"
|
|
64386
|
+
},
|
|
64239
64387
|
"dishwasher.getStatus": {
|
|
64240
64388
|
capName: "dishwasher",
|
|
64241
64389
|
capScope: "device",
|
|
@@ -64248,6 +64396,12 @@ Object.freeze({
|
|
|
64248
64396
|
addonId: null,
|
|
64249
64397
|
access: "create"
|
|
64250
64398
|
},
|
|
64399
|
+
"dishwasher.resume": {
|
|
64400
|
+
capName: "dishwasher",
|
|
64401
|
+
capScope: "device",
|
|
64402
|
+
addonId: null,
|
|
64403
|
+
access: "create"
|
|
64404
|
+
},
|
|
64251
64405
|
"dishwasher.setChildLock": {
|
|
64252
64406
|
capName: "dishwasher",
|
|
64253
64407
|
capScope: "device",
|
|
@@ -68748,6 +68902,12 @@ Object.freeze({
|
|
|
68748
68902
|
addonId: null,
|
|
68749
68903
|
access: "view"
|
|
68750
68904
|
},
|
|
68905
|
+
"storageMigration.moverClearance": {
|
|
68906
|
+
capName: "storage-migration",
|
|
68907
|
+
capScope: "system",
|
|
68908
|
+
addonId: null,
|
|
68909
|
+
access: "view"
|
|
68910
|
+
},
|
|
68751
68911
|
"storageMigration.movers": {
|
|
68752
68912
|
capName: "storage-migration",
|
|
68753
68913
|
capScope: "system",
|
|
@@ -70941,6 +71101,11 @@ Object.freeze({
|
|
|
70941
71101
|
form: "single",
|
|
70942
71102
|
optional: false
|
|
70943
71103
|
}],
|
|
71104
|
+
"dishwasher.getOptions": [{
|
|
71105
|
+
name: "deviceId",
|
|
71106
|
+
form: "single",
|
|
71107
|
+
optional: false
|
|
71108
|
+
}],
|
|
70944
71109
|
"dishwasher.getStatus": [{
|
|
70945
71110
|
name: "deviceId",
|
|
70946
71111
|
form: "single",
|
|
@@ -70951,6 +71116,11 @@ Object.freeze({
|
|
|
70951
71116
|
form: "single",
|
|
70952
71117
|
optional: false
|
|
70953
71118
|
}],
|
|
71119
|
+
"dishwasher.resume": [{
|
|
71120
|
+
name: "deviceId",
|
|
71121
|
+
form: "single",
|
|
71122
|
+
optional: false
|
|
71123
|
+
}],
|
|
70954
71124
|
"dishwasher.setChildLock": [{
|
|
70955
71125
|
name: "deviceId",
|
|
70956
71126
|
form: "single",
|
|
@@ -73037,6 +73207,9 @@ new Map(Object.entries({
|
|
|
73037
73207
|
"wrapper-update-available": "system",
|
|
73038
73208
|
"backup-completed": "system",
|
|
73039
73209
|
"export-completed": "system",
|
|
73210
|
+
"alert-critical": "system",
|
|
73211
|
+
"alert-error": "system",
|
|
73212
|
+
"alert-critical-resolved": "system",
|
|
73040
73213
|
"storage-location-low": "system",
|
|
73041
73214
|
"storage-location-critical": "system",
|
|
73042
73215
|
"storage-location-ok": "system",
|
|
@@ -73161,6 +73334,16 @@ var NC_SYSTEM_EVENT_KIND_GROUP_SPECS = [
|
|
|
73161
73334
|
"storage-location-ok"
|
|
73162
73335
|
]
|
|
73163
73336
|
},
|
|
73337
|
+
{
|
|
73338
|
+
id: "alerts",
|
|
73339
|
+
family: "system",
|
|
73340
|
+
label: "Alerts",
|
|
73341
|
+
kinds: [
|
|
73342
|
+
"alert-critical",
|
|
73343
|
+
"alert-error",
|
|
73344
|
+
"alert-critical-resolved"
|
|
73345
|
+
]
|
|
73346
|
+
},
|
|
73164
73347
|
{
|
|
73165
73348
|
id: "alarm",
|
|
73166
73349
|
family: "alarm",
|
|
@@ -73205,6 +73388,21 @@ var NC_SENSOR_RAISED_FIELD_BY_KIND = Object.freeze(Object.fromEntries(Object.ent
|
|
|
73205
73388
|
return [[descriptor.kind, field]];
|
|
73206
73389
|
})));
|
|
73207
73390
|
Object.freeze(Object.keys(NC_SENSOR_RAISED_FIELD_BY_KIND));
|
|
73391
|
+
object({
|
|
73392
|
+
phase: _enum(["raised", "resolved"]),
|
|
73393
|
+
episodeId: string().min(1),
|
|
73394
|
+
alertId: string().min(1),
|
|
73395
|
+
severity: AlertSeveritySchema,
|
|
73396
|
+
category: string(),
|
|
73397
|
+
title: string(),
|
|
73398
|
+
message: string(),
|
|
73399
|
+
sourceType: string().optional(),
|
|
73400
|
+
sourceId: string().optional(),
|
|
73401
|
+
nodeId: string().optional(),
|
|
73402
|
+
/** The alert's own action link (where the operator acts on it), when it has one. */
|
|
73403
|
+
actionUrl: string().optional(),
|
|
73404
|
+
at: number()
|
|
73405
|
+
});
|
|
73208
73406
|
var RULE_BODY_ONLY = ["body"];
|
|
73209
73407
|
var RULE_TEXT = ["title", "body"];
|
|
73210
73408
|
var BATTERY = ["device-battery-low", "device-battery-normal"];
|
|
@@ -73214,6 +73412,11 @@ var TANK = [
|
|
|
73214
73412
|
"device-tank-full",
|
|
73215
73413
|
"device-tank-normal"
|
|
73216
73414
|
];
|
|
73415
|
+
var ALERT_EPISODE = [
|
|
73416
|
+
"alert-critical",
|
|
73417
|
+
"alert-error",
|
|
73418
|
+
"alert-critical-resolved"
|
|
73419
|
+
];
|
|
73217
73420
|
var UPDATES = [
|
|
73218
73421
|
"addon-update-available",
|
|
73219
73422
|
"server-update-available",
|
|
@@ -73406,14 +73609,14 @@ var STATE_SUMMARY_VARS = [
|
|
|
73406
73609
|
([...RULE_TEXT], [...CONSUMABLE]),
|
|
73407
73610
|
([...RULE_TEXT], [...TANK]),
|
|
73408
73611
|
[...RULE_TEXT],
|
|
73409
|
-
([...RULE_TEXT], [...UPDATES]),
|
|
73410
|
-
([...RULE_TEXT], [...UPDATES]),
|
|
73411
|
-
[...RULE_TEXT],
|
|
73612
|
+
([...RULE_TEXT], [...UPDATES, ...ALERT_EPISODE]),
|
|
73613
|
+
([...RULE_TEXT], [...UPDATES, ...ALERT_EPISODE]),
|
|
73412
73614
|
[...RULE_TEXT],
|
|
73413
73615
|
[...RULE_TEXT],
|
|
73414
73616
|
[...RULE_TEXT],
|
|
73415
73617
|
[...RULE_TEXT],
|
|
73416
73618
|
[...RULE_TEXT],
|
|
73619
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
73417
73620
|
[...RULE_TEXT],
|
|
73418
73621
|
[...RULE_TEXT],
|
|
73419
73622
|
[...RULE_TEXT],
|
|
@@ -73431,7 +73634,11 @@ var STATE_SUMMARY_VARS = [
|
|
|
73431
73634
|
[...RULE_TEXT],
|
|
73432
73635
|
[...RULE_TEXT],
|
|
73433
73636
|
[...RULE_TEXT],
|
|
73434
|
-
[...RULE_TEXT],
|
|
73637
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
73638
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
73639
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
73640
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
73641
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
73435
73642
|
[...RULE_TEXT],
|
|
73436
73643
|
[...RULE_TEXT],
|
|
73437
73644
|
[...RULE_TEXT],
|
package/dist/index.mjs
CHANGED
|
@@ -1,5 +1,5 @@
|
|
|
1
1
|
import { randomUUID } from "node:crypto";
|
|
2
|
-
//#region ../types/dist/event-category-
|
|
2
|
+
//#region ../types/dist/event-category-DOl51-Ij.mjs
|
|
3
3
|
var EventCategory = /* @__PURE__ */ function(EventCategory) {
|
|
4
4
|
EventCategory["SystemBoot"] = "system.boot";
|
|
5
5
|
EventCategory["SystemAddonsReady"] = "system.addons-ready";
|
|
@@ -78,9 +78,18 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
|
|
|
78
78
|
/**
|
|
79
79
|
* The node's one-shot runner boot check (D877): planned runners against the
|
|
80
80
|
* process service, `degraded` when any is failed, refused or missing. The
|
|
81
|
-
* alert centre turns it into one
|
|
81
|
+
* alert centre turns it into one critical alert.
|
|
82
82
|
*/
|
|
83
83
|
EventCategory["SystemRunnerCheck"] = "system.runner-check";
|
|
84
|
+
/**
|
|
85
|
+
* An alert EPISODE opened or closed, emitted by the alert centre for alerts
|
|
86
|
+
* of severity `critical` or `error` (`AlertEpisodePayload`). The alert
|
|
87
|
+
* centre sends no notification of its own: Notification Center turns this
|
|
88
|
+
* into the `alert-critical` / `alert-error` / `alert-critical-resolved`
|
|
89
|
+
* system-event kinds, and reconciles from the alerts store because a bus
|
|
90
|
+
* event may be dropped (D8, D11).
|
|
91
|
+
*/
|
|
92
|
+
EventCategory["AlertEpisode"] = "alert.episode";
|
|
84
93
|
EventCategory["AddonError"] = "addon.error";
|
|
85
94
|
EventCategory["AddonPageReady"] = "addon.page-ready";
|
|
86
95
|
EventCategory["AddonWidgetReady"] = "addon.widget-ready";
|
|
@@ -5405,7 +5414,7 @@ var ZodIssueCode = {
|
|
|
5405
5414
|
var ZodFirstPartyTypeKind;
|
|
5406
5415
|
ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
|
|
5407
5416
|
//#endregion
|
|
5408
|
-
//#region ../types/dist/sleep-
|
|
5417
|
+
//#region ../types/dist/sleep-BxjU_fJM.mjs
|
|
5409
5418
|
/**
|
|
5410
5419
|
* The audio chunk plane's byte format, and the ONE expansion from a coded
|
|
5411
5420
|
* window to float samples (D455).
|
|
@@ -13097,7 +13106,14 @@ var AlertSeveritySchema = _enum([
|
|
|
13097
13106
|
]);
|
|
13098
13107
|
var AlertActionSchema = object({
|
|
13099
13108
|
label: string(),
|
|
13100
|
-
href: string().optional()
|
|
13109
|
+
href: string().optional(),
|
|
13110
|
+
/**
|
|
13111
|
+
* How `href` is followed. Absent / `app`: an admin-ui route (client-side).
|
|
13112
|
+
* `server`: a route the HUB serves (an addon HTTP route such as an OAuth
|
|
13113
|
+
* start) — the browser must leave the SPA with a full navigation, because
|
|
13114
|
+
* the SPA has no such route and would bounce to the home page.
|
|
13115
|
+
*/
|
|
13116
|
+
navigation: _enum(["app", "server"]).optional()
|
|
13101
13117
|
});
|
|
13102
13118
|
var AlertStatusSchema = _enum([
|
|
13103
13119
|
"active",
|
|
@@ -41591,6 +41607,9 @@ var NcSystemEventKindSchema = _enum([
|
|
|
41591
41607
|
"server-updated",
|
|
41592
41608
|
"export-completed",
|
|
41593
41609
|
"backup-completed",
|
|
41610
|
+
"alert-critical",
|
|
41611
|
+
"alert-error",
|
|
41612
|
+
"alert-critical-resolved",
|
|
41594
41613
|
"camera-online",
|
|
41595
41614
|
"camera-offline",
|
|
41596
41615
|
"camera-disabled",
|
|
@@ -50623,7 +50642,10 @@ method(StorageMigrationInputSchema, StorageMigrationPlanSchema, { auth: "admin"
|
|
|
50623
50642
|
}), method(object({ jobId: string().optional() }), StorageMigrationJobSchema.nullable(), { auth: "admin" }), method(object({ jobId: string() }), object({ cancelled: boolean() }), {
|
|
50624
50643
|
kind: "mutation",
|
|
50625
50644
|
auth: "admin"
|
|
50626
|
-
}), method(object({}), array(StorageMigrationMoverSchema).readonly(), { auth: "admin" }), method(object({
|
|
50645
|
+
}), method(object({}), array(StorageMigrationMoverSchema).readonly(), { auth: "admin" }), method(object({ locationIds: array(string()).readonly() }), object({
|
|
50646
|
+
clear: boolean(),
|
|
50647
|
+
repointLocationId: string().optional()
|
|
50648
|
+
}), { auth: "admin" }), method(object({}), array(StorageMigrationResidueSchema).readonly(), { auth: "admin" }), method(StorageMigrationDrainInputSchema, object({ jobId: string() }), {
|
|
50627
50649
|
kind: "mutation",
|
|
50628
50650
|
auth: "admin"
|
|
50629
50651
|
}), method(StorageCleanupInputSchema, object({ jobId: string() }), {
|
|
@@ -54058,6 +54080,11 @@ object({
|
|
|
54058
54080
|
*
|
|
54059
54081
|
* `kind: 'poll'` — cloud REST APIs typically have no push channel; the
|
|
54060
54082
|
* provider refreshes the slice on an interval and eagerly after commands.
|
|
54083
|
+
*
|
|
54084
|
+
* UNKNOWN IS NOT OFF. Every field the appliance reports separately is
|
|
54085
|
+
* nullable: `null` means "not known right now" (the appliance has not said,
|
|
54086
|
+
* the link is down, or the description does not carry it) and is never
|
|
54087
|
+
* rendered or exported as `false` / `0`. `availability` says why.
|
|
54061
54088
|
*/
|
|
54062
54089
|
var DishwasherStateSchema = _enum([
|
|
54063
54090
|
"idle",
|
|
@@ -54067,112 +54094,227 @@ var DishwasherStateSchema = _enum([
|
|
|
54067
54094
|
"error",
|
|
54068
54095
|
"unavailable"
|
|
54069
54096
|
]);
|
|
54097
|
+
/**
|
|
54098
|
+
* The appliance's own operation state, uncollapsed. `state` above is the coarse
|
|
54099
|
+
* view for compact surfaces; this is what the appliance said.
|
|
54100
|
+
*/
|
|
54101
|
+
var DishwasherOperationStateSchema = _enum([
|
|
54102
|
+
"Inactive",
|
|
54103
|
+
"Ready",
|
|
54104
|
+
"DelayedStart",
|
|
54105
|
+
"Run",
|
|
54106
|
+
"Pause",
|
|
54107
|
+
"ActionRequired",
|
|
54108
|
+
"Finished",
|
|
54109
|
+
"Error",
|
|
54110
|
+
"Aborting"
|
|
54111
|
+
]);
|
|
54112
|
+
/**
|
|
54113
|
+
* Why fields may be `null`:
|
|
54114
|
+
* - `available` — the link is up and the description is loaded;
|
|
54115
|
+
* - `offline` — the local link is down (values are unknown, not last-known);
|
|
54116
|
+
* - `description-missing` — the link is up but the appliance's description could not
|
|
54117
|
+
* be loaded, so its values cannot be decoded.
|
|
54118
|
+
*/
|
|
54119
|
+
var DishwasherAvailabilitySchema = _enum([
|
|
54120
|
+
"available",
|
|
54121
|
+
"offline",
|
|
54122
|
+
"description-missing"
|
|
54123
|
+
]);
|
|
54070
54124
|
var DishwasherConsumableLevelSchema = _enum([
|
|
54071
54125
|
"ok",
|
|
54072
54126
|
"low",
|
|
54073
54127
|
"empty"
|
|
54074
54128
|
]);
|
|
54075
54129
|
object({
|
|
54130
|
+
availability: DishwasherAvailabilitySchema,
|
|
54131
|
+
/** Coarse state for compact surfaces; `unavailable` whenever the appliance state is not known. */
|
|
54076
54132
|
state: DishwasherStateSchema,
|
|
54077
|
-
/**
|
|
54133
|
+
/** The appliance's operation state as reported; null when not known. */
|
|
54134
|
+
operationState: DishwasherOperationStateSchema.nullable(),
|
|
54135
|
+
/** Feature key of the ACTIVE (running) program, or null when none runs / not known. */
|
|
54078
54136
|
program: string().nullable(),
|
|
54079
|
-
/**
|
|
54137
|
+
/** Feature key of the SELECTED program (what Start would run), or null when none / not known. */
|
|
54138
|
+
selectedProgram: string().nullable(),
|
|
54139
|
+
/** Feature keys of the programs the appliance currently offers — drives the UI selector. */
|
|
54080
54140
|
availablePrograms: array(string()),
|
|
54081
|
-
/**
|
|
54082
|
-
|
|
54141
|
+
/** Seconds remaining on the active cycle, or null when not running / not known. */
|
|
54142
|
+
remainingSeconds: number().int().nonnegative().nullable(),
|
|
54143
|
+
/** Seconds the delayed start is set to (time until the cycle starts), or null. */
|
|
54144
|
+
delayedStartSeconds: number().int().nonnegative().nullable(),
|
|
54083
54145
|
/** Cycle completion 0..100, or null when not applicable. */
|
|
54084
54146
|
progressPercent: number().min(0).max(100).nullable(),
|
|
54085
|
-
/** True when the door is reported open. */
|
|
54086
|
-
doorOpen: boolean(),
|
|
54087
|
-
/** True when
|
|
54088
|
-
|
|
54089
|
-
/**
|
|
54090
|
-
|
|
54147
|
+
/** True when the door is reported open; null when the door state is not known. */
|
|
54148
|
+
doorOpen: boolean().nullable(),
|
|
54149
|
+
/** True when the door is latched (locked) during a cycle; null when not reported. */
|
|
54150
|
+
doorLocked: boolean().nullable(),
|
|
54151
|
+
/** True when remote start is allowed (door closed, power on, etc.); null when not known. */
|
|
54152
|
+
remoteStartAllowed: boolean().nullable(),
|
|
54153
|
+
/** True when the appliance accepts remote control now; null when not known. */
|
|
54154
|
+
remoteControlActive: boolean().nullable(),
|
|
54155
|
+
/** True while somebody operates the appliance at its panel; null when not reported. */
|
|
54156
|
+
localControlActive: boolean().nullable(),
|
|
54157
|
+
/** Main power / switched-on state; null when not known. */
|
|
54158
|
+
powerOn: boolean().nullable(),
|
|
54159
|
+
/** The raw power state (`On`, `Off`, `Standby`, …); null when not known. */
|
|
54160
|
+
powerState: string().nullable(),
|
|
54091
54161
|
saltLevel: DishwasherConsumableLevelSchema.nullable(),
|
|
54092
54162
|
rinseAidLevel: DishwasherConsumableLevelSchema.nullable(),
|
|
54093
|
-
|
|
54094
|
-
|
|
54163
|
+
/** Option states: null when the appliance does not expose the option or has not said. */
|
|
54164
|
+
halfLoad: boolean().nullable(),
|
|
54165
|
+
hygienePlus: boolean().nullable(),
|
|
54095
54166
|
/** Extra dry option when the appliance exposes it. */
|
|
54096
|
-
extraDry: boolean(),
|
|
54167
|
+
extraDry: boolean().nullable(),
|
|
54097
54168
|
/** Intensive zone (lower basket) when the appliance exposes it. */
|
|
54098
|
-
intensiveZone: boolean(),
|
|
54169
|
+
intensiveZone: boolean().nullable(),
|
|
54099
54170
|
/** VarioSpeed / VarioSpeed+ when the appliance exposes it. */
|
|
54100
|
-
varioSpeedPlus: boolean(),
|
|
54101
|
-
/** Child lock (controls disabled on the appliance). */
|
|
54102
|
-
childLock: boolean(),
|
|
54171
|
+
varioSpeedPlus: boolean().nullable(),
|
|
54172
|
+
/** Child lock (controls disabled on the appliance); null when not known. */
|
|
54173
|
+
childLock: boolean().nullable(),
|
|
54174
|
+
/** Feature keys of the events currently raised (salt low, rinse aid low, program finished, …). */
|
|
54175
|
+
activeEvents: array(string()),
|
|
54176
|
+
/** Numeric error code when the appliance reports one; null otherwise. */
|
|
54103
54177
|
errorCode: number().nullable(),
|
|
54178
|
+
/** Name of the raised alert-level event while the appliance is in error; null otherwise. */
|
|
54104
54179
|
errorLabel: string().nullable(),
|
|
54180
|
+
/** Ms epoch of the last value received from the appliance; 0 = never. */
|
|
54105
54181
|
lastFetchedAt: number()
|
|
54106
54182
|
});
|
|
54107
|
-
|
|
54183
|
+
var DeviceIdSchema = number().int().nonnegative();
|
|
54184
|
+
/** A value a program option or setting can take. */
|
|
54185
|
+
var DishwasherValueSchema = union([
|
|
54186
|
+
boolean(),
|
|
54187
|
+
string(),
|
|
54188
|
+
number()
|
|
54189
|
+
]);
|
|
54190
|
+
var DishwasherAccessSchema = _enum([
|
|
54191
|
+
"none",
|
|
54192
|
+
"read",
|
|
54193
|
+
"readWrite",
|
|
54194
|
+
"writeOnly",
|
|
54195
|
+
"readStatic"
|
|
54196
|
+
]);
|
|
54197
|
+
/**
|
|
54198
|
+
* One option or setting the appliance declares, with the constraints its description
|
|
54199
|
+
* gives. A `readWrite` descriptor that is `available` is what `setOption` accepts.
|
|
54200
|
+
*/
|
|
54201
|
+
var DishwasherOptionDescriptorSchema = object({
|
|
54202
|
+
/** Feature key (`Dishcare.Dishwasher.Option.ExtraDry`). */
|
|
54203
|
+
key: string(),
|
|
54204
|
+
/** Last segment of the key, for display. */
|
|
54205
|
+
name: string(),
|
|
54206
|
+
type: _enum([
|
|
54207
|
+
"boolean",
|
|
54208
|
+
"number",
|
|
54209
|
+
"enum",
|
|
54210
|
+
"string"
|
|
54211
|
+
]),
|
|
54212
|
+
access: DishwasherAccessSchema,
|
|
54213
|
+
/** The appliance reports this entity as currently available. */
|
|
54214
|
+
available: boolean(),
|
|
54215
|
+
/** Unit the description declares for a number; null when it declares none. */
|
|
54216
|
+
unit: string().nullable(),
|
|
54217
|
+
min: number().nullable(),
|
|
54218
|
+
max: number().nullable(),
|
|
54219
|
+
step: number().nullable(),
|
|
54220
|
+
/** Allowed members of an enum; null for other types. */
|
|
54221
|
+
enumValues: array(string()).nullable(),
|
|
54222
|
+
defaultValue: DishwasherValueSchema.nullable()
|
|
54223
|
+
});
|
|
54224
|
+
var DishwasherProgramSchema = object({
|
|
54225
|
+
/** Feature key (`Dishcare.Dishwasher.Program.Eco50`) — what `setProgram` / `start` take. */
|
|
54226
|
+
key: string(),
|
|
54227
|
+
name: string(),
|
|
54228
|
+
/** The appliance currently offers this program. */
|
|
54229
|
+
available: boolean(),
|
|
54230
|
+
/** The options this program lists, with the program-level access / availability / default. */
|
|
54231
|
+
options: array(DishwasherOptionDescriptorSchema)
|
|
54232
|
+
});
|
|
54233
|
+
var DishwasherOptionsSchema = object({
|
|
54234
|
+
availability: DishwasherAvailabilitySchema,
|
|
54235
|
+
/** What the appliance can be told to do, from the commands its description declares. */
|
|
54236
|
+
supportsStart: boolean(),
|
|
54237
|
+
supportsPause: boolean(),
|
|
54238
|
+
supportsResume: boolean(),
|
|
54239
|
+
supportsStop: boolean(),
|
|
54240
|
+
supportsPower: boolean(),
|
|
54241
|
+
/** Every program the description lists, with its options. */
|
|
54242
|
+
programs: array(DishwasherProgramSchema),
|
|
54243
|
+
/** Every option and setting entity the description lists (programs reference these by key). */
|
|
54244
|
+
options: array(DishwasherOptionDescriptorSchema)
|
|
54245
|
+
});
|
|
54246
|
+
DeviceType.Dishwasher, method(object({
|
|
54247
|
+
deviceId: DeviceIdSchema,
|
|
54248
|
+
program: string().min(1).optional(),
|
|
54249
|
+
options: record(string(), DishwasherValueSchema).optional()
|
|
54250
|
+
}), _void(), {
|
|
54108
54251
|
kind: "mutation",
|
|
54109
54252
|
auth: "protected"
|
|
54110
|
-
}), method(object({ deviceId:
|
|
54253
|
+
}), method(object({ deviceId: DeviceIdSchema }), _void(), {
|
|
54111
54254
|
kind: "mutation",
|
|
54112
54255
|
auth: "protected"
|
|
54113
|
-
}), method(object({ deviceId:
|
|
54256
|
+
}), method(object({ deviceId: DeviceIdSchema }), _void(), {
|
|
54257
|
+
kind: "mutation",
|
|
54258
|
+
auth: "protected"
|
|
54259
|
+
}), method(object({ deviceId: DeviceIdSchema }), _void(), {
|
|
54114
54260
|
kind: "mutation",
|
|
54115
54261
|
auth: "protected"
|
|
54116
54262
|
}), method(object({
|
|
54117
|
-
deviceId:
|
|
54263
|
+
deviceId: DeviceIdSchema,
|
|
54118
54264
|
program: string().min(1)
|
|
54119
54265
|
}), _void(), {
|
|
54120
54266
|
kind: "mutation",
|
|
54121
54267
|
auth: "protected"
|
|
54122
54268
|
}), method(object({
|
|
54123
|
-
deviceId:
|
|
54269
|
+
deviceId: DeviceIdSchema,
|
|
54124
54270
|
on: boolean()
|
|
54125
54271
|
}), _void(), {
|
|
54126
54272
|
kind: "mutation",
|
|
54127
54273
|
auth: "protected"
|
|
54128
54274
|
}), method(object({
|
|
54129
|
-
deviceId:
|
|
54275
|
+
deviceId: DeviceIdSchema,
|
|
54130
54276
|
on: boolean()
|
|
54131
54277
|
}), _void(), {
|
|
54132
54278
|
kind: "mutation",
|
|
54133
54279
|
auth: "protected"
|
|
54134
54280
|
}), method(object({
|
|
54135
|
-
deviceId:
|
|
54281
|
+
deviceId: DeviceIdSchema,
|
|
54136
54282
|
on: boolean()
|
|
54137
54283
|
}), _void(), {
|
|
54138
54284
|
kind: "mutation",
|
|
54139
54285
|
auth: "protected"
|
|
54140
54286
|
}), method(object({
|
|
54141
|
-
deviceId:
|
|
54287
|
+
deviceId: DeviceIdSchema,
|
|
54142
54288
|
on: boolean()
|
|
54143
54289
|
}), _void(), {
|
|
54144
54290
|
kind: "mutation",
|
|
54145
54291
|
auth: "protected"
|
|
54146
54292
|
}), method(object({
|
|
54147
|
-
deviceId:
|
|
54293
|
+
deviceId: DeviceIdSchema,
|
|
54148
54294
|
on: boolean()
|
|
54149
54295
|
}), _void(), {
|
|
54150
54296
|
kind: "mutation",
|
|
54151
54297
|
auth: "protected"
|
|
54152
54298
|
}), method(object({
|
|
54153
|
-
deviceId:
|
|
54299
|
+
deviceId: DeviceIdSchema,
|
|
54154
54300
|
on: boolean()
|
|
54155
54301
|
}), _void(), {
|
|
54156
54302
|
kind: "mutation",
|
|
54157
54303
|
auth: "protected"
|
|
54158
54304
|
}), method(object({
|
|
54159
|
-
deviceId:
|
|
54305
|
+
deviceId: DeviceIdSchema,
|
|
54160
54306
|
on: boolean()
|
|
54161
54307
|
}), _void(), {
|
|
54162
54308
|
kind: "mutation",
|
|
54163
54309
|
auth: "protected"
|
|
54164
54310
|
}), method(object({
|
|
54165
|
-
deviceId:
|
|
54311
|
+
deviceId: DeviceIdSchema,
|
|
54166
54312
|
key: string().min(1),
|
|
54167
|
-
value:
|
|
54168
|
-
boolean(),
|
|
54169
|
-
string(),
|
|
54170
|
-
number()
|
|
54171
|
-
])
|
|
54313
|
+
value: DishwasherValueSchema
|
|
54172
54314
|
}), _void(), {
|
|
54173
54315
|
kind: "mutation",
|
|
54174
54316
|
auth: "protected"
|
|
54175
|
-
});
|
|
54317
|
+
}), method(object({ deviceId: DeviceIdSchema }), DishwasherOptionsSchema, { auth: "protected" });
|
|
54176
54318
|
object({
|
|
54177
54319
|
/** Ms epoch of the last press. null = never observed since this provider started. */
|
|
54178
54320
|
lastPressedAt: number().nullable(),
|
|
@@ -64232,6 +64374,12 @@ Object.freeze({
|
|
|
64232
64374
|
addonId: null,
|
|
64233
64375
|
access: "view"
|
|
64234
64376
|
},
|
|
64377
|
+
"dishwasher.getOptions": {
|
|
64378
|
+
capName: "dishwasher",
|
|
64379
|
+
capScope: "device",
|
|
64380
|
+
addonId: null,
|
|
64381
|
+
access: "view"
|
|
64382
|
+
},
|
|
64235
64383
|
"dishwasher.getStatus": {
|
|
64236
64384
|
capName: "dishwasher",
|
|
64237
64385
|
capScope: "device",
|
|
@@ -64244,6 +64392,12 @@ Object.freeze({
|
|
|
64244
64392
|
addonId: null,
|
|
64245
64393
|
access: "create"
|
|
64246
64394
|
},
|
|
64395
|
+
"dishwasher.resume": {
|
|
64396
|
+
capName: "dishwasher",
|
|
64397
|
+
capScope: "device",
|
|
64398
|
+
addonId: null,
|
|
64399
|
+
access: "create"
|
|
64400
|
+
},
|
|
64247
64401
|
"dishwasher.setChildLock": {
|
|
64248
64402
|
capName: "dishwasher",
|
|
64249
64403
|
capScope: "device",
|
|
@@ -68744,6 +68898,12 @@ Object.freeze({
|
|
|
68744
68898
|
addonId: null,
|
|
68745
68899
|
access: "view"
|
|
68746
68900
|
},
|
|
68901
|
+
"storageMigration.moverClearance": {
|
|
68902
|
+
capName: "storage-migration",
|
|
68903
|
+
capScope: "system",
|
|
68904
|
+
addonId: null,
|
|
68905
|
+
access: "view"
|
|
68906
|
+
},
|
|
68747
68907
|
"storageMigration.movers": {
|
|
68748
68908
|
capName: "storage-migration",
|
|
68749
68909
|
capScope: "system",
|
|
@@ -70937,6 +71097,11 @@ Object.freeze({
|
|
|
70937
71097
|
form: "single",
|
|
70938
71098
|
optional: false
|
|
70939
71099
|
}],
|
|
71100
|
+
"dishwasher.getOptions": [{
|
|
71101
|
+
name: "deviceId",
|
|
71102
|
+
form: "single",
|
|
71103
|
+
optional: false
|
|
71104
|
+
}],
|
|
70940
71105
|
"dishwasher.getStatus": [{
|
|
70941
71106
|
name: "deviceId",
|
|
70942
71107
|
form: "single",
|
|
@@ -70947,6 +71112,11 @@ Object.freeze({
|
|
|
70947
71112
|
form: "single",
|
|
70948
71113
|
optional: false
|
|
70949
71114
|
}],
|
|
71115
|
+
"dishwasher.resume": [{
|
|
71116
|
+
name: "deviceId",
|
|
71117
|
+
form: "single",
|
|
71118
|
+
optional: false
|
|
71119
|
+
}],
|
|
70950
71120
|
"dishwasher.setChildLock": [{
|
|
70951
71121
|
name: "deviceId",
|
|
70952
71122
|
form: "single",
|
|
@@ -73033,6 +73203,9 @@ new Map(Object.entries({
|
|
|
73033
73203
|
"wrapper-update-available": "system",
|
|
73034
73204
|
"backup-completed": "system",
|
|
73035
73205
|
"export-completed": "system",
|
|
73206
|
+
"alert-critical": "system",
|
|
73207
|
+
"alert-error": "system",
|
|
73208
|
+
"alert-critical-resolved": "system",
|
|
73036
73209
|
"storage-location-low": "system",
|
|
73037
73210
|
"storage-location-critical": "system",
|
|
73038
73211
|
"storage-location-ok": "system",
|
|
@@ -73157,6 +73330,16 @@ var NC_SYSTEM_EVENT_KIND_GROUP_SPECS = [
|
|
|
73157
73330
|
"storage-location-ok"
|
|
73158
73331
|
]
|
|
73159
73332
|
},
|
|
73333
|
+
{
|
|
73334
|
+
id: "alerts",
|
|
73335
|
+
family: "system",
|
|
73336
|
+
label: "Alerts",
|
|
73337
|
+
kinds: [
|
|
73338
|
+
"alert-critical",
|
|
73339
|
+
"alert-error",
|
|
73340
|
+
"alert-critical-resolved"
|
|
73341
|
+
]
|
|
73342
|
+
},
|
|
73160
73343
|
{
|
|
73161
73344
|
id: "alarm",
|
|
73162
73345
|
family: "alarm",
|
|
@@ -73201,6 +73384,21 @@ var NC_SENSOR_RAISED_FIELD_BY_KIND = Object.freeze(Object.fromEntries(Object.ent
|
|
|
73201
73384
|
return [[descriptor.kind, field]];
|
|
73202
73385
|
})));
|
|
73203
73386
|
Object.freeze(Object.keys(NC_SENSOR_RAISED_FIELD_BY_KIND));
|
|
73387
|
+
object({
|
|
73388
|
+
phase: _enum(["raised", "resolved"]),
|
|
73389
|
+
episodeId: string().min(1),
|
|
73390
|
+
alertId: string().min(1),
|
|
73391
|
+
severity: AlertSeveritySchema,
|
|
73392
|
+
category: string(),
|
|
73393
|
+
title: string(),
|
|
73394
|
+
message: string(),
|
|
73395
|
+
sourceType: string().optional(),
|
|
73396
|
+
sourceId: string().optional(),
|
|
73397
|
+
nodeId: string().optional(),
|
|
73398
|
+
/** The alert's own action link (where the operator acts on it), when it has one. */
|
|
73399
|
+
actionUrl: string().optional(),
|
|
73400
|
+
at: number()
|
|
73401
|
+
});
|
|
73204
73402
|
var RULE_BODY_ONLY = ["body"];
|
|
73205
73403
|
var RULE_TEXT = ["title", "body"];
|
|
73206
73404
|
var BATTERY = ["device-battery-low", "device-battery-normal"];
|
|
@@ -73210,6 +73408,11 @@ var TANK = [
|
|
|
73210
73408
|
"device-tank-full",
|
|
73211
73409
|
"device-tank-normal"
|
|
73212
73410
|
];
|
|
73411
|
+
var ALERT_EPISODE = [
|
|
73412
|
+
"alert-critical",
|
|
73413
|
+
"alert-error",
|
|
73414
|
+
"alert-critical-resolved"
|
|
73415
|
+
];
|
|
73213
73416
|
var UPDATES = [
|
|
73214
73417
|
"addon-update-available",
|
|
73215
73418
|
"server-update-available",
|
|
@@ -73402,14 +73605,14 @@ var STATE_SUMMARY_VARS = [
|
|
|
73402
73605
|
([...RULE_TEXT], [...CONSUMABLE]),
|
|
73403
73606
|
([...RULE_TEXT], [...TANK]),
|
|
73404
73607
|
[...RULE_TEXT],
|
|
73405
|
-
([...RULE_TEXT], [...UPDATES]),
|
|
73406
|
-
([...RULE_TEXT], [...UPDATES]),
|
|
73407
|
-
[...RULE_TEXT],
|
|
73608
|
+
([...RULE_TEXT], [...UPDATES, ...ALERT_EPISODE]),
|
|
73609
|
+
([...RULE_TEXT], [...UPDATES, ...ALERT_EPISODE]),
|
|
73408
73610
|
[...RULE_TEXT],
|
|
73409
73611
|
[...RULE_TEXT],
|
|
73410
73612
|
[...RULE_TEXT],
|
|
73411
73613
|
[...RULE_TEXT],
|
|
73412
73614
|
[...RULE_TEXT],
|
|
73615
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
73413
73616
|
[...RULE_TEXT],
|
|
73414
73617
|
[...RULE_TEXT],
|
|
73415
73618
|
[...RULE_TEXT],
|
|
@@ -73427,7 +73630,11 @@ var STATE_SUMMARY_VARS = [
|
|
|
73427
73630
|
[...RULE_TEXT],
|
|
73428
73631
|
[...RULE_TEXT],
|
|
73429
73632
|
[...RULE_TEXT],
|
|
73430
|
-
[...RULE_TEXT],
|
|
73633
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
73634
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
73635
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
73636
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
73637
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
73431
73638
|
[...RULE_TEXT],
|
|
73432
73639
|
[...RULE_TEXT],
|
|
73433
73640
|
[...RULE_TEXT],
|