@camstack/addon-waste-collections 0.1.9 → 0.1.10
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/waste-collections.addon.js +251 -44
- package/dist/waste-collections.addon.mjs +251 -44
- package/package.json +1 -1
|
@@ -6,7 +6,7 @@ let node_fs = require("node:fs");
|
|
|
6
6
|
let node_path = require("node:path");
|
|
7
7
|
let node_child_process = require("node:child_process");
|
|
8
8
|
let node_url = require("node:url");
|
|
9
|
-
//#region ../types/dist/event-category-
|
|
9
|
+
//#region ../types/dist/event-category-DOl51-Ij.mjs
|
|
10
10
|
var EventCategory = /* @__PURE__ */ function(EventCategory) {
|
|
11
11
|
EventCategory["SystemBoot"] = "system.boot";
|
|
12
12
|
EventCategory["SystemAddonsReady"] = "system.addons-ready";
|
|
@@ -85,9 +85,18 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
|
|
|
85
85
|
/**
|
|
86
86
|
* The node's one-shot runner boot check (D877): planned runners against the
|
|
87
87
|
* process service, `degraded` when any is failed, refused or missing. The
|
|
88
|
-
* alert centre turns it into one
|
|
88
|
+
* alert centre turns it into one critical alert.
|
|
89
89
|
*/
|
|
90
90
|
EventCategory["SystemRunnerCheck"] = "system.runner-check";
|
|
91
|
+
/**
|
|
92
|
+
* An alert EPISODE opened or closed, emitted by the alert centre for alerts
|
|
93
|
+
* of severity `critical` or `error` (`AlertEpisodePayload`). The alert
|
|
94
|
+
* centre sends no notification of its own: Notification Center turns this
|
|
95
|
+
* into the `alert-critical` / `alert-error` / `alert-critical-resolved`
|
|
96
|
+
* system-event kinds, and reconciles from the alerts store because a bus
|
|
97
|
+
* event may be dropped (D8, D11).
|
|
98
|
+
*/
|
|
99
|
+
EventCategory["AlertEpisode"] = "alert.episode";
|
|
91
100
|
EventCategory["AddonError"] = "addon.error";
|
|
92
101
|
EventCategory["AddonPageReady"] = "addon.page-ready";
|
|
93
102
|
EventCategory["AddonWidgetReady"] = "addon.widget-ready";
|
|
@@ -5545,7 +5554,7 @@ var ZodIssueCode = {
|
|
|
5545
5554
|
var ZodFirstPartyTypeKind;
|
|
5546
5555
|
ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
|
|
5547
5556
|
//#endregion
|
|
5548
|
-
//#region ../types/dist/sleep-
|
|
5557
|
+
//#region ../types/dist/sleep-BxjU_fJM.mjs
|
|
5549
5558
|
/**
|
|
5550
5559
|
* The audio chunk plane's byte format, and the ONE expansion from a coded
|
|
5551
5560
|
* window to float samples (D455).
|
|
@@ -13525,7 +13534,14 @@ var AlertSeveritySchema = _enum([
|
|
|
13525
13534
|
]);
|
|
13526
13535
|
var AlertActionSchema = object({
|
|
13527
13536
|
label: string(),
|
|
13528
|
-
href: string().optional()
|
|
13537
|
+
href: string().optional(),
|
|
13538
|
+
/**
|
|
13539
|
+
* How `href` is followed. Absent / `app`: an admin-ui route (client-side).
|
|
13540
|
+
* `server`: a route the HUB serves (an addon HTTP route such as an OAuth
|
|
13541
|
+
* start) — the browser must leave the SPA with a full navigation, because
|
|
13542
|
+
* the SPA has no such route and would bounce to the home page.
|
|
13543
|
+
*/
|
|
13544
|
+
navigation: _enum(["app", "server"]).optional()
|
|
13529
13545
|
});
|
|
13530
13546
|
var AlertStatusSchema = _enum([
|
|
13531
13547
|
"active",
|
|
@@ -41901,6 +41917,9 @@ var NcSystemEventKindSchema = _enum([
|
|
|
41901
41917
|
"server-updated",
|
|
41902
41918
|
"export-completed",
|
|
41903
41919
|
"backup-completed",
|
|
41920
|
+
"alert-critical",
|
|
41921
|
+
"alert-error",
|
|
41922
|
+
"alert-critical-resolved",
|
|
41904
41923
|
"camera-online",
|
|
41905
41924
|
"camera-offline",
|
|
41906
41925
|
"camera-disabled",
|
|
@@ -50933,7 +50952,10 @@ method(StorageMigrationInputSchema, StorageMigrationPlanSchema, { auth: "admin"
|
|
|
50933
50952
|
}), method(object({ jobId: string().optional() }), StorageMigrationJobSchema.nullable(), { auth: "admin" }), method(object({ jobId: string() }), object({ cancelled: boolean() }), {
|
|
50934
50953
|
kind: "mutation",
|
|
50935
50954
|
auth: "admin"
|
|
50936
|
-
}), method(object({}), array(StorageMigrationMoverSchema).readonly(), { auth: "admin" }), method(object({
|
|
50955
|
+
}), method(object({}), array(StorageMigrationMoverSchema).readonly(), { auth: "admin" }), method(object({ locationIds: array(string()).readonly() }), object({
|
|
50956
|
+
clear: boolean(),
|
|
50957
|
+
repointLocationId: string().optional()
|
|
50958
|
+
}), { auth: "admin" }), method(object({}), array(StorageMigrationResidueSchema).readonly(), { auth: "admin" }), method(StorageMigrationDrainInputSchema, object({ jobId: string() }), {
|
|
50937
50959
|
kind: "mutation",
|
|
50938
50960
|
auth: "admin"
|
|
50939
50961
|
}), method(StorageCleanupInputSchema, object({ jobId: string() }), {
|
|
@@ -54378,6 +54400,11 @@ object({
|
|
|
54378
54400
|
*
|
|
54379
54401
|
* `kind: 'poll'` — cloud REST APIs typically have no push channel; the
|
|
54380
54402
|
* provider refreshes the slice on an interval and eagerly after commands.
|
|
54403
|
+
*
|
|
54404
|
+
* UNKNOWN IS NOT OFF. Every field the appliance reports separately is
|
|
54405
|
+
* nullable: `null` means "not known right now" (the appliance has not said,
|
|
54406
|
+
* the link is down, or the description does not carry it) and is never
|
|
54407
|
+
* rendered or exported as `false` / `0`. `availability` says why.
|
|
54381
54408
|
*/
|
|
54382
54409
|
var DishwasherStateSchema = _enum([
|
|
54383
54410
|
"idle",
|
|
@@ -54387,112 +54414,227 @@ var DishwasherStateSchema = _enum([
|
|
|
54387
54414
|
"error",
|
|
54388
54415
|
"unavailable"
|
|
54389
54416
|
]);
|
|
54417
|
+
/**
|
|
54418
|
+
* The appliance's own operation state, uncollapsed. `state` above is the coarse
|
|
54419
|
+
* view for compact surfaces; this is what the appliance said.
|
|
54420
|
+
*/
|
|
54421
|
+
var DishwasherOperationStateSchema = _enum([
|
|
54422
|
+
"Inactive",
|
|
54423
|
+
"Ready",
|
|
54424
|
+
"DelayedStart",
|
|
54425
|
+
"Run",
|
|
54426
|
+
"Pause",
|
|
54427
|
+
"ActionRequired",
|
|
54428
|
+
"Finished",
|
|
54429
|
+
"Error",
|
|
54430
|
+
"Aborting"
|
|
54431
|
+
]);
|
|
54432
|
+
/**
|
|
54433
|
+
* Why fields may be `null`:
|
|
54434
|
+
* - `available` — the link is up and the description is loaded;
|
|
54435
|
+
* - `offline` — the local link is down (values are unknown, not last-known);
|
|
54436
|
+
* - `description-missing` — the link is up but the appliance's description could not
|
|
54437
|
+
* be loaded, so its values cannot be decoded.
|
|
54438
|
+
*/
|
|
54439
|
+
var DishwasherAvailabilitySchema = _enum([
|
|
54440
|
+
"available",
|
|
54441
|
+
"offline",
|
|
54442
|
+
"description-missing"
|
|
54443
|
+
]);
|
|
54390
54444
|
var DishwasherConsumableLevelSchema = _enum([
|
|
54391
54445
|
"ok",
|
|
54392
54446
|
"low",
|
|
54393
54447
|
"empty"
|
|
54394
54448
|
]);
|
|
54395
54449
|
object({
|
|
54450
|
+
availability: DishwasherAvailabilitySchema,
|
|
54451
|
+
/** Coarse state for compact surfaces; `unavailable` whenever the appliance state is not known. */
|
|
54396
54452
|
state: DishwasherStateSchema,
|
|
54397
|
-
/**
|
|
54453
|
+
/** The appliance's operation state as reported; null when not known. */
|
|
54454
|
+
operationState: DishwasherOperationStateSchema.nullable(),
|
|
54455
|
+
/** Feature key of the ACTIVE (running) program, or null when none runs / not known. */
|
|
54398
54456
|
program: string().nullable(),
|
|
54399
|
-
/**
|
|
54457
|
+
/** Feature key of the SELECTED program (what Start would run), or null when none / not known. */
|
|
54458
|
+
selectedProgram: string().nullable(),
|
|
54459
|
+
/** Feature keys of the programs the appliance currently offers — drives the UI selector. */
|
|
54400
54460
|
availablePrograms: array(string()),
|
|
54401
|
-
/**
|
|
54402
|
-
|
|
54461
|
+
/** Seconds remaining on the active cycle, or null when not running / not known. */
|
|
54462
|
+
remainingSeconds: number().int().nonnegative().nullable(),
|
|
54463
|
+
/** Seconds the delayed start is set to (time until the cycle starts), or null. */
|
|
54464
|
+
delayedStartSeconds: number().int().nonnegative().nullable(),
|
|
54403
54465
|
/** Cycle completion 0..100, or null when not applicable. */
|
|
54404
54466
|
progressPercent: number().min(0).max(100).nullable(),
|
|
54405
|
-
/** True when the door is reported open. */
|
|
54406
|
-
doorOpen: boolean(),
|
|
54407
|
-
/** True when
|
|
54408
|
-
|
|
54409
|
-
/**
|
|
54410
|
-
|
|
54467
|
+
/** True when the door is reported open; null when the door state is not known. */
|
|
54468
|
+
doorOpen: boolean().nullable(),
|
|
54469
|
+
/** True when the door is latched (locked) during a cycle; null when not reported. */
|
|
54470
|
+
doorLocked: boolean().nullable(),
|
|
54471
|
+
/** True when remote start is allowed (door closed, power on, etc.); null when not known. */
|
|
54472
|
+
remoteStartAllowed: boolean().nullable(),
|
|
54473
|
+
/** True when the appliance accepts remote control now; null when not known. */
|
|
54474
|
+
remoteControlActive: boolean().nullable(),
|
|
54475
|
+
/** True while somebody operates the appliance at its panel; null when not reported. */
|
|
54476
|
+
localControlActive: boolean().nullable(),
|
|
54477
|
+
/** Main power / switched-on state; null when not known. */
|
|
54478
|
+
powerOn: boolean().nullable(),
|
|
54479
|
+
/** The raw power state (`On`, `Off`, `Standby`, …); null when not known. */
|
|
54480
|
+
powerState: string().nullable(),
|
|
54411
54481
|
saltLevel: DishwasherConsumableLevelSchema.nullable(),
|
|
54412
54482
|
rinseAidLevel: DishwasherConsumableLevelSchema.nullable(),
|
|
54413
|
-
|
|
54414
|
-
|
|
54483
|
+
/** Option states: null when the appliance does not expose the option or has not said. */
|
|
54484
|
+
halfLoad: boolean().nullable(),
|
|
54485
|
+
hygienePlus: boolean().nullable(),
|
|
54415
54486
|
/** Extra dry option when the appliance exposes it. */
|
|
54416
|
-
extraDry: boolean(),
|
|
54487
|
+
extraDry: boolean().nullable(),
|
|
54417
54488
|
/** Intensive zone (lower basket) when the appliance exposes it. */
|
|
54418
|
-
intensiveZone: boolean(),
|
|
54489
|
+
intensiveZone: boolean().nullable(),
|
|
54419
54490
|
/** VarioSpeed / VarioSpeed+ when the appliance exposes it. */
|
|
54420
|
-
varioSpeedPlus: boolean(),
|
|
54421
|
-
/** Child lock (controls disabled on the appliance). */
|
|
54422
|
-
childLock: boolean(),
|
|
54491
|
+
varioSpeedPlus: boolean().nullable(),
|
|
54492
|
+
/** Child lock (controls disabled on the appliance); null when not known. */
|
|
54493
|
+
childLock: boolean().nullable(),
|
|
54494
|
+
/** Feature keys of the events currently raised (salt low, rinse aid low, program finished, …). */
|
|
54495
|
+
activeEvents: array(string()),
|
|
54496
|
+
/** Numeric error code when the appliance reports one; null otherwise. */
|
|
54423
54497
|
errorCode: number().nullable(),
|
|
54498
|
+
/** Name of the raised alert-level event while the appliance is in error; null otherwise. */
|
|
54424
54499
|
errorLabel: string().nullable(),
|
|
54500
|
+
/** Ms epoch of the last value received from the appliance; 0 = never. */
|
|
54425
54501
|
lastFetchedAt: number()
|
|
54426
54502
|
});
|
|
54427
|
-
|
|
54503
|
+
var DeviceIdSchema = number().int().nonnegative();
|
|
54504
|
+
/** A value a program option or setting can take. */
|
|
54505
|
+
var DishwasherValueSchema = union([
|
|
54506
|
+
boolean(),
|
|
54507
|
+
string(),
|
|
54508
|
+
number()
|
|
54509
|
+
]);
|
|
54510
|
+
var DishwasherAccessSchema = _enum([
|
|
54511
|
+
"none",
|
|
54512
|
+
"read",
|
|
54513
|
+
"readWrite",
|
|
54514
|
+
"writeOnly",
|
|
54515
|
+
"readStatic"
|
|
54516
|
+
]);
|
|
54517
|
+
/**
|
|
54518
|
+
* One option or setting the appliance declares, with the constraints its description
|
|
54519
|
+
* gives. A `readWrite` descriptor that is `available` is what `setOption` accepts.
|
|
54520
|
+
*/
|
|
54521
|
+
var DishwasherOptionDescriptorSchema = object({
|
|
54522
|
+
/** Feature key (`Dishcare.Dishwasher.Option.ExtraDry`). */
|
|
54523
|
+
key: string(),
|
|
54524
|
+
/** Last segment of the key, for display. */
|
|
54525
|
+
name: string(),
|
|
54526
|
+
type: _enum([
|
|
54527
|
+
"boolean",
|
|
54528
|
+
"number",
|
|
54529
|
+
"enum",
|
|
54530
|
+
"string"
|
|
54531
|
+
]),
|
|
54532
|
+
access: DishwasherAccessSchema,
|
|
54533
|
+
/** The appliance reports this entity as currently available. */
|
|
54534
|
+
available: boolean(),
|
|
54535
|
+
/** Unit the description declares for a number; null when it declares none. */
|
|
54536
|
+
unit: string().nullable(),
|
|
54537
|
+
min: number().nullable(),
|
|
54538
|
+
max: number().nullable(),
|
|
54539
|
+
step: number().nullable(),
|
|
54540
|
+
/** Allowed members of an enum; null for other types. */
|
|
54541
|
+
enumValues: array(string()).nullable(),
|
|
54542
|
+
defaultValue: DishwasherValueSchema.nullable()
|
|
54543
|
+
});
|
|
54544
|
+
var DishwasherProgramSchema = object({
|
|
54545
|
+
/** Feature key (`Dishcare.Dishwasher.Program.Eco50`) — what `setProgram` / `start` take. */
|
|
54546
|
+
key: string(),
|
|
54547
|
+
name: string(),
|
|
54548
|
+
/** The appliance currently offers this program. */
|
|
54549
|
+
available: boolean(),
|
|
54550
|
+
/** The options this program lists, with the program-level access / availability / default. */
|
|
54551
|
+
options: array(DishwasherOptionDescriptorSchema)
|
|
54552
|
+
});
|
|
54553
|
+
var DishwasherOptionsSchema = object({
|
|
54554
|
+
availability: DishwasherAvailabilitySchema,
|
|
54555
|
+
/** What the appliance can be told to do, from the commands its description declares. */
|
|
54556
|
+
supportsStart: boolean(),
|
|
54557
|
+
supportsPause: boolean(),
|
|
54558
|
+
supportsResume: boolean(),
|
|
54559
|
+
supportsStop: boolean(),
|
|
54560
|
+
supportsPower: boolean(),
|
|
54561
|
+
/** Every program the description lists, with its options. */
|
|
54562
|
+
programs: array(DishwasherProgramSchema),
|
|
54563
|
+
/** Every option and setting entity the description lists (programs reference these by key). */
|
|
54564
|
+
options: array(DishwasherOptionDescriptorSchema)
|
|
54565
|
+
});
|
|
54566
|
+
DeviceType.Dishwasher, method(object({
|
|
54567
|
+
deviceId: DeviceIdSchema,
|
|
54568
|
+
program: string().min(1).optional(),
|
|
54569
|
+
options: record(string(), DishwasherValueSchema).optional()
|
|
54570
|
+
}), _void(), {
|
|
54428
54571
|
kind: "mutation",
|
|
54429
54572
|
auth: "protected"
|
|
54430
|
-
}), method(object({ deviceId:
|
|
54573
|
+
}), method(object({ deviceId: DeviceIdSchema }), _void(), {
|
|
54431
54574
|
kind: "mutation",
|
|
54432
54575
|
auth: "protected"
|
|
54433
|
-
}), method(object({ deviceId:
|
|
54576
|
+
}), method(object({ deviceId: DeviceIdSchema }), _void(), {
|
|
54577
|
+
kind: "mutation",
|
|
54578
|
+
auth: "protected"
|
|
54579
|
+
}), method(object({ deviceId: DeviceIdSchema }), _void(), {
|
|
54434
54580
|
kind: "mutation",
|
|
54435
54581
|
auth: "protected"
|
|
54436
54582
|
}), method(object({
|
|
54437
|
-
deviceId:
|
|
54583
|
+
deviceId: DeviceIdSchema,
|
|
54438
54584
|
program: string().min(1)
|
|
54439
54585
|
}), _void(), {
|
|
54440
54586
|
kind: "mutation",
|
|
54441
54587
|
auth: "protected"
|
|
54442
54588
|
}), method(object({
|
|
54443
|
-
deviceId:
|
|
54589
|
+
deviceId: DeviceIdSchema,
|
|
54444
54590
|
on: boolean()
|
|
54445
54591
|
}), _void(), {
|
|
54446
54592
|
kind: "mutation",
|
|
54447
54593
|
auth: "protected"
|
|
54448
54594
|
}), method(object({
|
|
54449
|
-
deviceId:
|
|
54595
|
+
deviceId: DeviceIdSchema,
|
|
54450
54596
|
on: boolean()
|
|
54451
54597
|
}), _void(), {
|
|
54452
54598
|
kind: "mutation",
|
|
54453
54599
|
auth: "protected"
|
|
54454
54600
|
}), method(object({
|
|
54455
|
-
deviceId:
|
|
54601
|
+
deviceId: DeviceIdSchema,
|
|
54456
54602
|
on: boolean()
|
|
54457
54603
|
}), _void(), {
|
|
54458
54604
|
kind: "mutation",
|
|
54459
54605
|
auth: "protected"
|
|
54460
54606
|
}), method(object({
|
|
54461
|
-
deviceId:
|
|
54607
|
+
deviceId: DeviceIdSchema,
|
|
54462
54608
|
on: boolean()
|
|
54463
54609
|
}), _void(), {
|
|
54464
54610
|
kind: "mutation",
|
|
54465
54611
|
auth: "protected"
|
|
54466
54612
|
}), method(object({
|
|
54467
|
-
deviceId:
|
|
54613
|
+
deviceId: DeviceIdSchema,
|
|
54468
54614
|
on: boolean()
|
|
54469
54615
|
}), _void(), {
|
|
54470
54616
|
kind: "mutation",
|
|
54471
54617
|
auth: "protected"
|
|
54472
54618
|
}), method(object({
|
|
54473
|
-
deviceId:
|
|
54619
|
+
deviceId: DeviceIdSchema,
|
|
54474
54620
|
on: boolean()
|
|
54475
54621
|
}), _void(), {
|
|
54476
54622
|
kind: "mutation",
|
|
54477
54623
|
auth: "protected"
|
|
54478
54624
|
}), method(object({
|
|
54479
|
-
deviceId:
|
|
54625
|
+
deviceId: DeviceIdSchema,
|
|
54480
54626
|
on: boolean()
|
|
54481
54627
|
}), _void(), {
|
|
54482
54628
|
kind: "mutation",
|
|
54483
54629
|
auth: "protected"
|
|
54484
54630
|
}), method(object({
|
|
54485
|
-
deviceId:
|
|
54631
|
+
deviceId: DeviceIdSchema,
|
|
54486
54632
|
key: string().min(1),
|
|
54487
|
-
value:
|
|
54488
|
-
boolean(),
|
|
54489
|
-
string(),
|
|
54490
|
-
number()
|
|
54491
|
-
])
|
|
54633
|
+
value: DishwasherValueSchema
|
|
54492
54634
|
}), _void(), {
|
|
54493
54635
|
kind: "mutation",
|
|
54494
54636
|
auth: "protected"
|
|
54495
|
-
});
|
|
54637
|
+
}), method(object({ deviceId: DeviceIdSchema }), DishwasherOptionsSchema, { auth: "protected" });
|
|
54496
54638
|
object({
|
|
54497
54639
|
/** Ms epoch of the last press. null = never observed since this provider started. */
|
|
54498
54640
|
lastPressedAt: number().nullable(),
|
|
@@ -64552,6 +64694,12 @@ Object.freeze({
|
|
|
64552
64694
|
addonId: null,
|
|
64553
64695
|
access: "view"
|
|
64554
64696
|
},
|
|
64697
|
+
"dishwasher.getOptions": {
|
|
64698
|
+
capName: "dishwasher",
|
|
64699
|
+
capScope: "device",
|
|
64700
|
+
addonId: null,
|
|
64701
|
+
access: "view"
|
|
64702
|
+
},
|
|
64555
64703
|
"dishwasher.getStatus": {
|
|
64556
64704
|
capName: "dishwasher",
|
|
64557
64705
|
capScope: "device",
|
|
@@ -64564,6 +64712,12 @@ Object.freeze({
|
|
|
64564
64712
|
addonId: null,
|
|
64565
64713
|
access: "create"
|
|
64566
64714
|
},
|
|
64715
|
+
"dishwasher.resume": {
|
|
64716
|
+
capName: "dishwasher",
|
|
64717
|
+
capScope: "device",
|
|
64718
|
+
addonId: null,
|
|
64719
|
+
access: "create"
|
|
64720
|
+
},
|
|
64567
64721
|
"dishwasher.setChildLock": {
|
|
64568
64722
|
capName: "dishwasher",
|
|
64569
64723
|
capScope: "device",
|
|
@@ -69064,6 +69218,12 @@ Object.freeze({
|
|
|
69064
69218
|
addonId: null,
|
|
69065
69219
|
access: "view"
|
|
69066
69220
|
},
|
|
69221
|
+
"storageMigration.moverClearance": {
|
|
69222
|
+
capName: "storage-migration",
|
|
69223
|
+
capScope: "system",
|
|
69224
|
+
addonId: null,
|
|
69225
|
+
access: "view"
|
|
69226
|
+
},
|
|
69067
69227
|
"storageMigration.movers": {
|
|
69068
69228
|
capName: "storage-migration",
|
|
69069
69229
|
capScope: "system",
|
|
@@ -71257,6 +71417,11 @@ Object.freeze({
|
|
|
71257
71417
|
form: "single",
|
|
71258
71418
|
optional: false
|
|
71259
71419
|
}],
|
|
71420
|
+
"dishwasher.getOptions": [{
|
|
71421
|
+
name: "deviceId",
|
|
71422
|
+
form: "single",
|
|
71423
|
+
optional: false
|
|
71424
|
+
}],
|
|
71260
71425
|
"dishwasher.getStatus": [{
|
|
71261
71426
|
name: "deviceId",
|
|
71262
71427
|
form: "single",
|
|
@@ -71267,6 +71432,11 @@ Object.freeze({
|
|
|
71267
71432
|
form: "single",
|
|
71268
71433
|
optional: false
|
|
71269
71434
|
}],
|
|
71435
|
+
"dishwasher.resume": [{
|
|
71436
|
+
name: "deviceId",
|
|
71437
|
+
form: "single",
|
|
71438
|
+
optional: false
|
|
71439
|
+
}],
|
|
71270
71440
|
"dishwasher.setChildLock": [{
|
|
71271
71441
|
name: "deviceId",
|
|
71272
71442
|
form: "single",
|
|
@@ -73353,6 +73523,9 @@ new Map(Object.entries({
|
|
|
73353
73523
|
"wrapper-update-available": "system",
|
|
73354
73524
|
"backup-completed": "system",
|
|
73355
73525
|
"export-completed": "system",
|
|
73526
|
+
"alert-critical": "system",
|
|
73527
|
+
"alert-error": "system",
|
|
73528
|
+
"alert-critical-resolved": "system",
|
|
73356
73529
|
"storage-location-low": "system",
|
|
73357
73530
|
"storage-location-critical": "system",
|
|
73358
73531
|
"storage-location-ok": "system",
|
|
@@ -73477,6 +73650,16 @@ var NC_SYSTEM_EVENT_KIND_GROUP_SPECS = [
|
|
|
73477
73650
|
"storage-location-ok"
|
|
73478
73651
|
]
|
|
73479
73652
|
},
|
|
73653
|
+
{
|
|
73654
|
+
id: "alerts",
|
|
73655
|
+
family: "system",
|
|
73656
|
+
label: "Alerts",
|
|
73657
|
+
kinds: [
|
|
73658
|
+
"alert-critical",
|
|
73659
|
+
"alert-error",
|
|
73660
|
+
"alert-critical-resolved"
|
|
73661
|
+
]
|
|
73662
|
+
},
|
|
73480
73663
|
{
|
|
73481
73664
|
id: "alarm",
|
|
73482
73665
|
family: "alarm",
|
|
@@ -73521,6 +73704,21 @@ var NC_SENSOR_RAISED_FIELD_BY_KIND = Object.freeze(Object.fromEntries(Object.ent
|
|
|
73521
73704
|
return [[descriptor.kind, field]];
|
|
73522
73705
|
})));
|
|
73523
73706
|
Object.freeze(Object.keys(NC_SENSOR_RAISED_FIELD_BY_KIND));
|
|
73707
|
+
object({
|
|
73708
|
+
phase: _enum(["raised", "resolved"]),
|
|
73709
|
+
episodeId: string().min(1),
|
|
73710
|
+
alertId: string().min(1),
|
|
73711
|
+
severity: AlertSeveritySchema,
|
|
73712
|
+
category: string(),
|
|
73713
|
+
title: string(),
|
|
73714
|
+
message: string(),
|
|
73715
|
+
sourceType: string().optional(),
|
|
73716
|
+
sourceId: string().optional(),
|
|
73717
|
+
nodeId: string().optional(),
|
|
73718
|
+
/** The alert's own action link (where the operator acts on it), when it has one. */
|
|
73719
|
+
actionUrl: string().optional(),
|
|
73720
|
+
at: number()
|
|
73721
|
+
});
|
|
73524
73722
|
var RULE_BODY_ONLY = ["body"];
|
|
73525
73723
|
var RULE_TEXT = ["title", "body"];
|
|
73526
73724
|
var BATTERY = ["device-battery-low", "device-battery-normal"];
|
|
@@ -73530,6 +73728,11 @@ var TANK = [
|
|
|
73530
73728
|
"device-tank-full",
|
|
73531
73729
|
"device-tank-normal"
|
|
73532
73730
|
];
|
|
73731
|
+
var ALERT_EPISODE = [
|
|
73732
|
+
"alert-critical",
|
|
73733
|
+
"alert-error",
|
|
73734
|
+
"alert-critical-resolved"
|
|
73735
|
+
];
|
|
73533
73736
|
var UPDATES = [
|
|
73534
73737
|
"addon-update-available",
|
|
73535
73738
|
"server-update-available",
|
|
@@ -73722,14 +73925,14 @@ var STATE_SUMMARY_VARS = [
|
|
|
73722
73925
|
([...RULE_TEXT], [...CONSUMABLE]),
|
|
73723
73926
|
([...RULE_TEXT], [...TANK]),
|
|
73724
73927
|
[...RULE_TEXT],
|
|
73725
|
-
([...RULE_TEXT], [...UPDATES]),
|
|
73726
|
-
([...RULE_TEXT], [...UPDATES]),
|
|
73727
|
-
[...RULE_TEXT],
|
|
73928
|
+
([...RULE_TEXT], [...UPDATES, ...ALERT_EPISODE]),
|
|
73929
|
+
([...RULE_TEXT], [...UPDATES, ...ALERT_EPISODE]),
|
|
73728
73930
|
[...RULE_TEXT],
|
|
73729
73931
|
[...RULE_TEXT],
|
|
73730
73932
|
[...RULE_TEXT],
|
|
73731
73933
|
[...RULE_TEXT],
|
|
73732
73934
|
[...RULE_TEXT],
|
|
73935
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
73733
73936
|
[...RULE_TEXT],
|
|
73734
73937
|
[...RULE_TEXT],
|
|
73735
73938
|
[...RULE_TEXT],
|
|
@@ -73747,7 +73950,11 @@ var STATE_SUMMARY_VARS = [
|
|
|
73747
73950
|
[...RULE_TEXT],
|
|
73748
73951
|
[...RULE_TEXT],
|
|
73749
73952
|
[...RULE_TEXT],
|
|
73750
|
-
[...RULE_TEXT],
|
|
73953
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
73954
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
73955
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
73956
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
73957
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
73751
73958
|
[...RULE_TEXT],
|
|
73752
73959
|
[...RULE_TEXT],
|
|
73753
73960
|
[...RULE_TEXT],
|
|
@@ -2,7 +2,7 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
|
|
|
2
2
|
import { dirname, join } from "node:path";
|
|
3
3
|
import { spawn } from "node:child_process";
|
|
4
4
|
import { fileURLToPath } from "node:url";
|
|
5
|
-
//#region ../types/dist/event-category-
|
|
5
|
+
//#region ../types/dist/event-category-DOl51-Ij.mjs
|
|
6
6
|
var EventCategory = /* @__PURE__ */ function(EventCategory) {
|
|
7
7
|
EventCategory["SystemBoot"] = "system.boot";
|
|
8
8
|
EventCategory["SystemAddonsReady"] = "system.addons-ready";
|
|
@@ -81,9 +81,18 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
|
|
|
81
81
|
/**
|
|
82
82
|
* The node's one-shot runner boot check (D877): planned runners against the
|
|
83
83
|
* process service, `degraded` when any is failed, refused or missing. The
|
|
84
|
-
* alert centre turns it into one
|
|
84
|
+
* alert centre turns it into one critical alert.
|
|
85
85
|
*/
|
|
86
86
|
EventCategory["SystemRunnerCheck"] = "system.runner-check";
|
|
87
|
+
/**
|
|
88
|
+
* An alert EPISODE opened or closed, emitted by the alert centre for alerts
|
|
89
|
+
* of severity `critical` or `error` (`AlertEpisodePayload`). The alert
|
|
90
|
+
* centre sends no notification of its own: Notification Center turns this
|
|
91
|
+
* into the `alert-critical` / `alert-error` / `alert-critical-resolved`
|
|
92
|
+
* system-event kinds, and reconciles from the alerts store because a bus
|
|
93
|
+
* event may be dropped (D8, D11).
|
|
94
|
+
*/
|
|
95
|
+
EventCategory["AlertEpisode"] = "alert.episode";
|
|
87
96
|
EventCategory["AddonError"] = "addon.error";
|
|
88
97
|
EventCategory["AddonPageReady"] = "addon.page-ready";
|
|
89
98
|
EventCategory["AddonWidgetReady"] = "addon.widget-ready";
|
|
@@ -5541,7 +5550,7 @@ var ZodIssueCode = {
|
|
|
5541
5550
|
var ZodFirstPartyTypeKind;
|
|
5542
5551
|
ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
|
|
5543
5552
|
//#endregion
|
|
5544
|
-
//#region ../types/dist/sleep-
|
|
5553
|
+
//#region ../types/dist/sleep-BxjU_fJM.mjs
|
|
5545
5554
|
/**
|
|
5546
5555
|
* The audio chunk plane's byte format, and the ONE expansion from a coded
|
|
5547
5556
|
* window to float samples (D455).
|
|
@@ -13521,7 +13530,14 @@ var AlertSeveritySchema = _enum([
|
|
|
13521
13530
|
]);
|
|
13522
13531
|
var AlertActionSchema = object({
|
|
13523
13532
|
label: string(),
|
|
13524
|
-
href: string().optional()
|
|
13533
|
+
href: string().optional(),
|
|
13534
|
+
/**
|
|
13535
|
+
* How `href` is followed. Absent / `app`: an admin-ui route (client-side).
|
|
13536
|
+
* `server`: a route the HUB serves (an addon HTTP route such as an OAuth
|
|
13537
|
+
* start) — the browser must leave the SPA with a full navigation, because
|
|
13538
|
+
* the SPA has no such route and would bounce to the home page.
|
|
13539
|
+
*/
|
|
13540
|
+
navigation: _enum(["app", "server"]).optional()
|
|
13525
13541
|
});
|
|
13526
13542
|
var AlertStatusSchema = _enum([
|
|
13527
13543
|
"active",
|
|
@@ -41897,6 +41913,9 @@ var NcSystemEventKindSchema = _enum([
|
|
|
41897
41913
|
"server-updated",
|
|
41898
41914
|
"export-completed",
|
|
41899
41915
|
"backup-completed",
|
|
41916
|
+
"alert-critical",
|
|
41917
|
+
"alert-error",
|
|
41918
|
+
"alert-critical-resolved",
|
|
41900
41919
|
"camera-online",
|
|
41901
41920
|
"camera-offline",
|
|
41902
41921
|
"camera-disabled",
|
|
@@ -50929,7 +50948,10 @@ method(StorageMigrationInputSchema, StorageMigrationPlanSchema, { auth: "admin"
|
|
|
50929
50948
|
}), method(object({ jobId: string().optional() }), StorageMigrationJobSchema.nullable(), { auth: "admin" }), method(object({ jobId: string() }), object({ cancelled: boolean() }), {
|
|
50930
50949
|
kind: "mutation",
|
|
50931
50950
|
auth: "admin"
|
|
50932
|
-
}), method(object({}), array(StorageMigrationMoverSchema).readonly(), { auth: "admin" }), method(object({
|
|
50951
|
+
}), method(object({}), array(StorageMigrationMoverSchema).readonly(), { auth: "admin" }), method(object({ locationIds: array(string()).readonly() }), object({
|
|
50952
|
+
clear: boolean(),
|
|
50953
|
+
repointLocationId: string().optional()
|
|
50954
|
+
}), { auth: "admin" }), method(object({}), array(StorageMigrationResidueSchema).readonly(), { auth: "admin" }), method(StorageMigrationDrainInputSchema, object({ jobId: string() }), {
|
|
50933
50955
|
kind: "mutation",
|
|
50934
50956
|
auth: "admin"
|
|
50935
50957
|
}), method(StorageCleanupInputSchema, object({ jobId: string() }), {
|
|
@@ -54374,6 +54396,11 @@ object({
|
|
|
54374
54396
|
*
|
|
54375
54397
|
* `kind: 'poll'` — cloud REST APIs typically have no push channel; the
|
|
54376
54398
|
* provider refreshes the slice on an interval and eagerly after commands.
|
|
54399
|
+
*
|
|
54400
|
+
* UNKNOWN IS NOT OFF. Every field the appliance reports separately is
|
|
54401
|
+
* nullable: `null` means "not known right now" (the appliance has not said,
|
|
54402
|
+
* the link is down, or the description does not carry it) and is never
|
|
54403
|
+
* rendered or exported as `false` / `0`. `availability` says why.
|
|
54377
54404
|
*/
|
|
54378
54405
|
var DishwasherStateSchema = _enum([
|
|
54379
54406
|
"idle",
|
|
@@ -54383,112 +54410,227 @@ var DishwasherStateSchema = _enum([
|
|
|
54383
54410
|
"error",
|
|
54384
54411
|
"unavailable"
|
|
54385
54412
|
]);
|
|
54413
|
+
/**
|
|
54414
|
+
* The appliance's own operation state, uncollapsed. `state` above is the coarse
|
|
54415
|
+
* view for compact surfaces; this is what the appliance said.
|
|
54416
|
+
*/
|
|
54417
|
+
var DishwasherOperationStateSchema = _enum([
|
|
54418
|
+
"Inactive",
|
|
54419
|
+
"Ready",
|
|
54420
|
+
"DelayedStart",
|
|
54421
|
+
"Run",
|
|
54422
|
+
"Pause",
|
|
54423
|
+
"ActionRequired",
|
|
54424
|
+
"Finished",
|
|
54425
|
+
"Error",
|
|
54426
|
+
"Aborting"
|
|
54427
|
+
]);
|
|
54428
|
+
/**
|
|
54429
|
+
* Why fields may be `null`:
|
|
54430
|
+
* - `available` — the link is up and the description is loaded;
|
|
54431
|
+
* - `offline` — the local link is down (values are unknown, not last-known);
|
|
54432
|
+
* - `description-missing` — the link is up but the appliance's description could not
|
|
54433
|
+
* be loaded, so its values cannot be decoded.
|
|
54434
|
+
*/
|
|
54435
|
+
var DishwasherAvailabilitySchema = _enum([
|
|
54436
|
+
"available",
|
|
54437
|
+
"offline",
|
|
54438
|
+
"description-missing"
|
|
54439
|
+
]);
|
|
54386
54440
|
var DishwasherConsumableLevelSchema = _enum([
|
|
54387
54441
|
"ok",
|
|
54388
54442
|
"low",
|
|
54389
54443
|
"empty"
|
|
54390
54444
|
]);
|
|
54391
54445
|
object({
|
|
54446
|
+
availability: DishwasherAvailabilitySchema,
|
|
54447
|
+
/** Coarse state for compact surfaces; `unavailable` whenever the appliance state is not known. */
|
|
54392
54448
|
state: DishwasherStateSchema,
|
|
54393
|
-
/**
|
|
54449
|
+
/** The appliance's operation state as reported; null when not known. */
|
|
54450
|
+
operationState: DishwasherOperationStateSchema.nullable(),
|
|
54451
|
+
/** Feature key of the ACTIVE (running) program, or null when none runs / not known. */
|
|
54394
54452
|
program: string().nullable(),
|
|
54395
|
-
/**
|
|
54453
|
+
/** Feature key of the SELECTED program (what Start would run), or null when none / not known. */
|
|
54454
|
+
selectedProgram: string().nullable(),
|
|
54455
|
+
/** Feature keys of the programs the appliance currently offers — drives the UI selector. */
|
|
54396
54456
|
availablePrograms: array(string()),
|
|
54397
|
-
/**
|
|
54398
|
-
|
|
54457
|
+
/** Seconds remaining on the active cycle, or null when not running / not known. */
|
|
54458
|
+
remainingSeconds: number().int().nonnegative().nullable(),
|
|
54459
|
+
/** Seconds the delayed start is set to (time until the cycle starts), or null. */
|
|
54460
|
+
delayedStartSeconds: number().int().nonnegative().nullable(),
|
|
54399
54461
|
/** Cycle completion 0..100, or null when not applicable. */
|
|
54400
54462
|
progressPercent: number().min(0).max(100).nullable(),
|
|
54401
|
-
/** True when the door is reported open. */
|
|
54402
|
-
doorOpen: boolean(),
|
|
54403
|
-
/** True when
|
|
54404
|
-
|
|
54405
|
-
/**
|
|
54406
|
-
|
|
54463
|
+
/** True when the door is reported open; null when the door state is not known. */
|
|
54464
|
+
doorOpen: boolean().nullable(),
|
|
54465
|
+
/** True when the door is latched (locked) during a cycle; null when not reported. */
|
|
54466
|
+
doorLocked: boolean().nullable(),
|
|
54467
|
+
/** True when remote start is allowed (door closed, power on, etc.); null when not known. */
|
|
54468
|
+
remoteStartAllowed: boolean().nullable(),
|
|
54469
|
+
/** True when the appliance accepts remote control now; null when not known. */
|
|
54470
|
+
remoteControlActive: boolean().nullable(),
|
|
54471
|
+
/** True while somebody operates the appliance at its panel; null when not reported. */
|
|
54472
|
+
localControlActive: boolean().nullable(),
|
|
54473
|
+
/** Main power / switched-on state; null when not known. */
|
|
54474
|
+
powerOn: boolean().nullable(),
|
|
54475
|
+
/** The raw power state (`On`, `Off`, `Standby`, …); null when not known. */
|
|
54476
|
+
powerState: string().nullable(),
|
|
54407
54477
|
saltLevel: DishwasherConsumableLevelSchema.nullable(),
|
|
54408
54478
|
rinseAidLevel: DishwasherConsumableLevelSchema.nullable(),
|
|
54409
|
-
|
|
54410
|
-
|
|
54479
|
+
/** Option states: null when the appliance does not expose the option or has not said. */
|
|
54480
|
+
halfLoad: boolean().nullable(),
|
|
54481
|
+
hygienePlus: boolean().nullable(),
|
|
54411
54482
|
/** Extra dry option when the appliance exposes it. */
|
|
54412
|
-
extraDry: boolean(),
|
|
54483
|
+
extraDry: boolean().nullable(),
|
|
54413
54484
|
/** Intensive zone (lower basket) when the appliance exposes it. */
|
|
54414
|
-
intensiveZone: boolean(),
|
|
54485
|
+
intensiveZone: boolean().nullable(),
|
|
54415
54486
|
/** VarioSpeed / VarioSpeed+ when the appliance exposes it. */
|
|
54416
|
-
varioSpeedPlus: boolean(),
|
|
54417
|
-
/** Child lock (controls disabled on the appliance). */
|
|
54418
|
-
childLock: boolean(),
|
|
54487
|
+
varioSpeedPlus: boolean().nullable(),
|
|
54488
|
+
/** Child lock (controls disabled on the appliance); null when not known. */
|
|
54489
|
+
childLock: boolean().nullable(),
|
|
54490
|
+
/** Feature keys of the events currently raised (salt low, rinse aid low, program finished, …). */
|
|
54491
|
+
activeEvents: array(string()),
|
|
54492
|
+
/** Numeric error code when the appliance reports one; null otherwise. */
|
|
54419
54493
|
errorCode: number().nullable(),
|
|
54494
|
+
/** Name of the raised alert-level event while the appliance is in error; null otherwise. */
|
|
54420
54495
|
errorLabel: string().nullable(),
|
|
54496
|
+
/** Ms epoch of the last value received from the appliance; 0 = never. */
|
|
54421
54497
|
lastFetchedAt: number()
|
|
54422
54498
|
});
|
|
54423
|
-
|
|
54499
|
+
var DeviceIdSchema = number().int().nonnegative();
|
|
54500
|
+
/** A value a program option or setting can take. */
|
|
54501
|
+
var DishwasherValueSchema = union([
|
|
54502
|
+
boolean(),
|
|
54503
|
+
string(),
|
|
54504
|
+
number()
|
|
54505
|
+
]);
|
|
54506
|
+
var DishwasherAccessSchema = _enum([
|
|
54507
|
+
"none",
|
|
54508
|
+
"read",
|
|
54509
|
+
"readWrite",
|
|
54510
|
+
"writeOnly",
|
|
54511
|
+
"readStatic"
|
|
54512
|
+
]);
|
|
54513
|
+
/**
|
|
54514
|
+
* One option or setting the appliance declares, with the constraints its description
|
|
54515
|
+
* gives. A `readWrite` descriptor that is `available` is what `setOption` accepts.
|
|
54516
|
+
*/
|
|
54517
|
+
var DishwasherOptionDescriptorSchema = object({
|
|
54518
|
+
/** Feature key (`Dishcare.Dishwasher.Option.ExtraDry`). */
|
|
54519
|
+
key: string(),
|
|
54520
|
+
/** Last segment of the key, for display. */
|
|
54521
|
+
name: string(),
|
|
54522
|
+
type: _enum([
|
|
54523
|
+
"boolean",
|
|
54524
|
+
"number",
|
|
54525
|
+
"enum",
|
|
54526
|
+
"string"
|
|
54527
|
+
]),
|
|
54528
|
+
access: DishwasherAccessSchema,
|
|
54529
|
+
/** The appliance reports this entity as currently available. */
|
|
54530
|
+
available: boolean(),
|
|
54531
|
+
/** Unit the description declares for a number; null when it declares none. */
|
|
54532
|
+
unit: string().nullable(),
|
|
54533
|
+
min: number().nullable(),
|
|
54534
|
+
max: number().nullable(),
|
|
54535
|
+
step: number().nullable(),
|
|
54536
|
+
/** Allowed members of an enum; null for other types. */
|
|
54537
|
+
enumValues: array(string()).nullable(),
|
|
54538
|
+
defaultValue: DishwasherValueSchema.nullable()
|
|
54539
|
+
});
|
|
54540
|
+
var DishwasherProgramSchema = object({
|
|
54541
|
+
/** Feature key (`Dishcare.Dishwasher.Program.Eco50`) — what `setProgram` / `start` take. */
|
|
54542
|
+
key: string(),
|
|
54543
|
+
name: string(),
|
|
54544
|
+
/** The appliance currently offers this program. */
|
|
54545
|
+
available: boolean(),
|
|
54546
|
+
/** The options this program lists, with the program-level access / availability / default. */
|
|
54547
|
+
options: array(DishwasherOptionDescriptorSchema)
|
|
54548
|
+
});
|
|
54549
|
+
var DishwasherOptionsSchema = object({
|
|
54550
|
+
availability: DishwasherAvailabilitySchema,
|
|
54551
|
+
/** What the appliance can be told to do, from the commands its description declares. */
|
|
54552
|
+
supportsStart: boolean(),
|
|
54553
|
+
supportsPause: boolean(),
|
|
54554
|
+
supportsResume: boolean(),
|
|
54555
|
+
supportsStop: boolean(),
|
|
54556
|
+
supportsPower: boolean(),
|
|
54557
|
+
/** Every program the description lists, with its options. */
|
|
54558
|
+
programs: array(DishwasherProgramSchema),
|
|
54559
|
+
/** Every option and setting entity the description lists (programs reference these by key). */
|
|
54560
|
+
options: array(DishwasherOptionDescriptorSchema)
|
|
54561
|
+
});
|
|
54562
|
+
DeviceType.Dishwasher, method(object({
|
|
54563
|
+
deviceId: DeviceIdSchema,
|
|
54564
|
+
program: string().min(1).optional(),
|
|
54565
|
+
options: record(string(), DishwasherValueSchema).optional()
|
|
54566
|
+
}), _void(), {
|
|
54424
54567
|
kind: "mutation",
|
|
54425
54568
|
auth: "protected"
|
|
54426
|
-
}), method(object({ deviceId:
|
|
54569
|
+
}), method(object({ deviceId: DeviceIdSchema }), _void(), {
|
|
54427
54570
|
kind: "mutation",
|
|
54428
54571
|
auth: "protected"
|
|
54429
|
-
}), method(object({ deviceId:
|
|
54572
|
+
}), method(object({ deviceId: DeviceIdSchema }), _void(), {
|
|
54573
|
+
kind: "mutation",
|
|
54574
|
+
auth: "protected"
|
|
54575
|
+
}), method(object({ deviceId: DeviceIdSchema }), _void(), {
|
|
54430
54576
|
kind: "mutation",
|
|
54431
54577
|
auth: "protected"
|
|
54432
54578
|
}), method(object({
|
|
54433
|
-
deviceId:
|
|
54579
|
+
deviceId: DeviceIdSchema,
|
|
54434
54580
|
program: string().min(1)
|
|
54435
54581
|
}), _void(), {
|
|
54436
54582
|
kind: "mutation",
|
|
54437
54583
|
auth: "protected"
|
|
54438
54584
|
}), method(object({
|
|
54439
|
-
deviceId:
|
|
54585
|
+
deviceId: DeviceIdSchema,
|
|
54440
54586
|
on: boolean()
|
|
54441
54587
|
}), _void(), {
|
|
54442
54588
|
kind: "mutation",
|
|
54443
54589
|
auth: "protected"
|
|
54444
54590
|
}), method(object({
|
|
54445
|
-
deviceId:
|
|
54591
|
+
deviceId: DeviceIdSchema,
|
|
54446
54592
|
on: boolean()
|
|
54447
54593
|
}), _void(), {
|
|
54448
54594
|
kind: "mutation",
|
|
54449
54595
|
auth: "protected"
|
|
54450
54596
|
}), method(object({
|
|
54451
|
-
deviceId:
|
|
54597
|
+
deviceId: DeviceIdSchema,
|
|
54452
54598
|
on: boolean()
|
|
54453
54599
|
}), _void(), {
|
|
54454
54600
|
kind: "mutation",
|
|
54455
54601
|
auth: "protected"
|
|
54456
54602
|
}), method(object({
|
|
54457
|
-
deviceId:
|
|
54603
|
+
deviceId: DeviceIdSchema,
|
|
54458
54604
|
on: boolean()
|
|
54459
54605
|
}), _void(), {
|
|
54460
54606
|
kind: "mutation",
|
|
54461
54607
|
auth: "protected"
|
|
54462
54608
|
}), method(object({
|
|
54463
|
-
deviceId:
|
|
54609
|
+
deviceId: DeviceIdSchema,
|
|
54464
54610
|
on: boolean()
|
|
54465
54611
|
}), _void(), {
|
|
54466
54612
|
kind: "mutation",
|
|
54467
54613
|
auth: "protected"
|
|
54468
54614
|
}), method(object({
|
|
54469
|
-
deviceId:
|
|
54615
|
+
deviceId: DeviceIdSchema,
|
|
54470
54616
|
on: boolean()
|
|
54471
54617
|
}), _void(), {
|
|
54472
54618
|
kind: "mutation",
|
|
54473
54619
|
auth: "protected"
|
|
54474
54620
|
}), method(object({
|
|
54475
|
-
deviceId:
|
|
54621
|
+
deviceId: DeviceIdSchema,
|
|
54476
54622
|
on: boolean()
|
|
54477
54623
|
}), _void(), {
|
|
54478
54624
|
kind: "mutation",
|
|
54479
54625
|
auth: "protected"
|
|
54480
54626
|
}), method(object({
|
|
54481
|
-
deviceId:
|
|
54627
|
+
deviceId: DeviceIdSchema,
|
|
54482
54628
|
key: string().min(1),
|
|
54483
|
-
value:
|
|
54484
|
-
boolean(),
|
|
54485
|
-
string(),
|
|
54486
|
-
number()
|
|
54487
|
-
])
|
|
54629
|
+
value: DishwasherValueSchema
|
|
54488
54630
|
}), _void(), {
|
|
54489
54631
|
kind: "mutation",
|
|
54490
54632
|
auth: "protected"
|
|
54491
|
-
});
|
|
54633
|
+
}), method(object({ deviceId: DeviceIdSchema }), DishwasherOptionsSchema, { auth: "protected" });
|
|
54492
54634
|
object({
|
|
54493
54635
|
/** Ms epoch of the last press. null = never observed since this provider started. */
|
|
54494
54636
|
lastPressedAt: number().nullable(),
|
|
@@ -64548,6 +64690,12 @@ Object.freeze({
|
|
|
64548
64690
|
addonId: null,
|
|
64549
64691
|
access: "view"
|
|
64550
64692
|
},
|
|
64693
|
+
"dishwasher.getOptions": {
|
|
64694
|
+
capName: "dishwasher",
|
|
64695
|
+
capScope: "device",
|
|
64696
|
+
addonId: null,
|
|
64697
|
+
access: "view"
|
|
64698
|
+
},
|
|
64551
64699
|
"dishwasher.getStatus": {
|
|
64552
64700
|
capName: "dishwasher",
|
|
64553
64701
|
capScope: "device",
|
|
@@ -64560,6 +64708,12 @@ Object.freeze({
|
|
|
64560
64708
|
addonId: null,
|
|
64561
64709
|
access: "create"
|
|
64562
64710
|
},
|
|
64711
|
+
"dishwasher.resume": {
|
|
64712
|
+
capName: "dishwasher",
|
|
64713
|
+
capScope: "device",
|
|
64714
|
+
addonId: null,
|
|
64715
|
+
access: "create"
|
|
64716
|
+
},
|
|
64563
64717
|
"dishwasher.setChildLock": {
|
|
64564
64718
|
capName: "dishwasher",
|
|
64565
64719
|
capScope: "device",
|
|
@@ -69060,6 +69214,12 @@ Object.freeze({
|
|
|
69060
69214
|
addonId: null,
|
|
69061
69215
|
access: "view"
|
|
69062
69216
|
},
|
|
69217
|
+
"storageMigration.moverClearance": {
|
|
69218
|
+
capName: "storage-migration",
|
|
69219
|
+
capScope: "system",
|
|
69220
|
+
addonId: null,
|
|
69221
|
+
access: "view"
|
|
69222
|
+
},
|
|
69063
69223
|
"storageMigration.movers": {
|
|
69064
69224
|
capName: "storage-migration",
|
|
69065
69225
|
capScope: "system",
|
|
@@ -71253,6 +71413,11 @@ Object.freeze({
|
|
|
71253
71413
|
form: "single",
|
|
71254
71414
|
optional: false
|
|
71255
71415
|
}],
|
|
71416
|
+
"dishwasher.getOptions": [{
|
|
71417
|
+
name: "deviceId",
|
|
71418
|
+
form: "single",
|
|
71419
|
+
optional: false
|
|
71420
|
+
}],
|
|
71256
71421
|
"dishwasher.getStatus": [{
|
|
71257
71422
|
name: "deviceId",
|
|
71258
71423
|
form: "single",
|
|
@@ -71263,6 +71428,11 @@ Object.freeze({
|
|
|
71263
71428
|
form: "single",
|
|
71264
71429
|
optional: false
|
|
71265
71430
|
}],
|
|
71431
|
+
"dishwasher.resume": [{
|
|
71432
|
+
name: "deviceId",
|
|
71433
|
+
form: "single",
|
|
71434
|
+
optional: false
|
|
71435
|
+
}],
|
|
71266
71436
|
"dishwasher.setChildLock": [{
|
|
71267
71437
|
name: "deviceId",
|
|
71268
71438
|
form: "single",
|
|
@@ -73349,6 +73519,9 @@ new Map(Object.entries({
|
|
|
73349
73519
|
"wrapper-update-available": "system",
|
|
73350
73520
|
"backup-completed": "system",
|
|
73351
73521
|
"export-completed": "system",
|
|
73522
|
+
"alert-critical": "system",
|
|
73523
|
+
"alert-error": "system",
|
|
73524
|
+
"alert-critical-resolved": "system",
|
|
73352
73525
|
"storage-location-low": "system",
|
|
73353
73526
|
"storage-location-critical": "system",
|
|
73354
73527
|
"storage-location-ok": "system",
|
|
@@ -73473,6 +73646,16 @@ var NC_SYSTEM_EVENT_KIND_GROUP_SPECS = [
|
|
|
73473
73646
|
"storage-location-ok"
|
|
73474
73647
|
]
|
|
73475
73648
|
},
|
|
73649
|
+
{
|
|
73650
|
+
id: "alerts",
|
|
73651
|
+
family: "system",
|
|
73652
|
+
label: "Alerts",
|
|
73653
|
+
kinds: [
|
|
73654
|
+
"alert-critical",
|
|
73655
|
+
"alert-error",
|
|
73656
|
+
"alert-critical-resolved"
|
|
73657
|
+
]
|
|
73658
|
+
},
|
|
73476
73659
|
{
|
|
73477
73660
|
id: "alarm",
|
|
73478
73661
|
family: "alarm",
|
|
@@ -73517,6 +73700,21 @@ var NC_SENSOR_RAISED_FIELD_BY_KIND = Object.freeze(Object.fromEntries(Object.ent
|
|
|
73517
73700
|
return [[descriptor.kind, field]];
|
|
73518
73701
|
})));
|
|
73519
73702
|
Object.freeze(Object.keys(NC_SENSOR_RAISED_FIELD_BY_KIND));
|
|
73703
|
+
object({
|
|
73704
|
+
phase: _enum(["raised", "resolved"]),
|
|
73705
|
+
episodeId: string().min(1),
|
|
73706
|
+
alertId: string().min(1),
|
|
73707
|
+
severity: AlertSeveritySchema,
|
|
73708
|
+
category: string(),
|
|
73709
|
+
title: string(),
|
|
73710
|
+
message: string(),
|
|
73711
|
+
sourceType: string().optional(),
|
|
73712
|
+
sourceId: string().optional(),
|
|
73713
|
+
nodeId: string().optional(),
|
|
73714
|
+
/** The alert's own action link (where the operator acts on it), when it has one. */
|
|
73715
|
+
actionUrl: string().optional(),
|
|
73716
|
+
at: number()
|
|
73717
|
+
});
|
|
73520
73718
|
var RULE_BODY_ONLY = ["body"];
|
|
73521
73719
|
var RULE_TEXT = ["title", "body"];
|
|
73522
73720
|
var BATTERY = ["device-battery-low", "device-battery-normal"];
|
|
@@ -73526,6 +73724,11 @@ var TANK = [
|
|
|
73526
73724
|
"device-tank-full",
|
|
73527
73725
|
"device-tank-normal"
|
|
73528
73726
|
];
|
|
73727
|
+
var ALERT_EPISODE = [
|
|
73728
|
+
"alert-critical",
|
|
73729
|
+
"alert-error",
|
|
73730
|
+
"alert-critical-resolved"
|
|
73731
|
+
];
|
|
73529
73732
|
var UPDATES = [
|
|
73530
73733
|
"addon-update-available",
|
|
73531
73734
|
"server-update-available",
|
|
@@ -73718,14 +73921,14 @@ var STATE_SUMMARY_VARS = [
|
|
|
73718
73921
|
([...RULE_TEXT], [...CONSUMABLE]),
|
|
73719
73922
|
([...RULE_TEXT], [...TANK]),
|
|
73720
73923
|
[...RULE_TEXT],
|
|
73721
|
-
([...RULE_TEXT], [...UPDATES]),
|
|
73722
|
-
([...RULE_TEXT], [...UPDATES]),
|
|
73723
|
-
[...RULE_TEXT],
|
|
73924
|
+
([...RULE_TEXT], [...UPDATES, ...ALERT_EPISODE]),
|
|
73925
|
+
([...RULE_TEXT], [...UPDATES, ...ALERT_EPISODE]),
|
|
73724
73926
|
[...RULE_TEXT],
|
|
73725
73927
|
[...RULE_TEXT],
|
|
73726
73928
|
[...RULE_TEXT],
|
|
73727
73929
|
[...RULE_TEXT],
|
|
73728
73930
|
[...RULE_TEXT],
|
|
73931
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
73729
73932
|
[...RULE_TEXT],
|
|
73730
73933
|
[...RULE_TEXT],
|
|
73731
73934
|
[...RULE_TEXT],
|
|
@@ -73743,7 +73946,11 @@ var STATE_SUMMARY_VARS = [
|
|
|
73743
73946
|
[...RULE_TEXT],
|
|
73744
73947
|
[...RULE_TEXT],
|
|
73745
73948
|
[...RULE_TEXT],
|
|
73746
|
-
[...RULE_TEXT],
|
|
73949
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
73950
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
73951
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
73952
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
73953
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
73747
73954
|
[...RULE_TEXT],
|
|
73748
73955
|
[...RULE_TEXT],
|
|
73749
73956
|
[...RULE_TEXT],
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@camstack/addon-waste-collections",
|
|
3
|
-
"version": "0.1.
|
|
3
|
+
"version": "0.1.10",
|
|
4
4
|
"description": "Waste collection schedules via the vendored HACS waste_collection_schedule Python core — full source catalog as calendar-source.",
|
|
5
5
|
"keywords": [
|
|
6
6
|
"camstack",
|