@camstack/addon-export-google 0.1.94 → 0.1.95
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/export-google.addon.js +251 -44
- package/dist/export-google.addon.mjs +251 -44
- package/package.json +1 -1
|
@@ -77,7 +77,7 @@ function createApiDeviceGateway(deps) {
|
|
|
77
77
|
};
|
|
78
78
|
}
|
|
79
79
|
//#endregion
|
|
80
|
-
//#region ../types/dist/event-category-
|
|
80
|
+
//#region ../types/dist/event-category-DOl51-Ij.mjs
|
|
81
81
|
var EventCategory = /* @__PURE__ */ function(EventCategory) {
|
|
82
82
|
EventCategory["SystemBoot"] = "system.boot";
|
|
83
83
|
EventCategory["SystemAddonsReady"] = "system.addons-ready";
|
|
@@ -156,9 +156,18 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
|
|
|
156
156
|
/**
|
|
157
157
|
* The node's one-shot runner boot check (D877): planned runners against the
|
|
158
158
|
* process service, `degraded` when any is failed, refused or missing. The
|
|
159
|
-
* alert centre turns it into one
|
|
159
|
+
* alert centre turns it into one critical alert.
|
|
160
160
|
*/
|
|
161
161
|
EventCategory["SystemRunnerCheck"] = "system.runner-check";
|
|
162
|
+
/**
|
|
163
|
+
* An alert EPISODE opened or closed, emitted by the alert centre for alerts
|
|
164
|
+
* of severity `critical` or `error` (`AlertEpisodePayload`). The alert
|
|
165
|
+
* centre sends no notification of its own: Notification Center turns this
|
|
166
|
+
* into the `alert-critical` / `alert-error` / `alert-critical-resolved`
|
|
167
|
+
* system-event kinds, and reconciles from the alerts store because a bus
|
|
168
|
+
* event may be dropped (D8, D11).
|
|
169
|
+
*/
|
|
170
|
+
EventCategory["AlertEpisode"] = "alert.episode";
|
|
162
171
|
EventCategory["AddonError"] = "addon.error";
|
|
163
172
|
EventCategory["AddonPageReady"] = "addon.page-ready";
|
|
164
173
|
EventCategory["AddonWidgetReady"] = "addon.widget-ready";
|
|
@@ -5483,7 +5492,7 @@ var ZodIssueCode = {
|
|
|
5483
5492
|
var ZodFirstPartyTypeKind;
|
|
5484
5493
|
ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
|
|
5485
5494
|
//#endregion
|
|
5486
|
-
//#region ../types/dist/sleep-
|
|
5495
|
+
//#region ../types/dist/sleep-BxjU_fJM.mjs
|
|
5487
5496
|
/**
|
|
5488
5497
|
* The audio chunk plane's byte format, and the ONE expansion from a coded
|
|
5489
5498
|
* window to float samples (D455).
|
|
@@ -13340,7 +13349,14 @@ var AlertSeveritySchema = _enum([
|
|
|
13340
13349
|
]);
|
|
13341
13350
|
var AlertActionSchema = object({
|
|
13342
13351
|
label: string(),
|
|
13343
|
-
href: string().optional()
|
|
13352
|
+
href: string().optional(),
|
|
13353
|
+
/**
|
|
13354
|
+
* How `href` is followed. Absent / `app`: an admin-ui route (client-side).
|
|
13355
|
+
* `server`: a route the HUB serves (an addon HTTP route such as an OAuth
|
|
13356
|
+
* start) — the browser must leave the SPA with a full navigation, because
|
|
13357
|
+
* the SPA has no such route and would bounce to the home page.
|
|
13358
|
+
*/
|
|
13359
|
+
navigation: _enum(["app", "server"]).optional()
|
|
13344
13360
|
});
|
|
13345
13361
|
var AlertStatusSchema = _enum([
|
|
13346
13362
|
"active",
|
|
@@ -41741,6 +41757,9 @@ var NcSystemEventKindSchema = _enum([
|
|
|
41741
41757
|
"server-updated",
|
|
41742
41758
|
"export-completed",
|
|
41743
41759
|
"backup-completed",
|
|
41760
|
+
"alert-critical",
|
|
41761
|
+
"alert-error",
|
|
41762
|
+
"alert-critical-resolved",
|
|
41744
41763
|
"camera-online",
|
|
41745
41764
|
"camera-offline",
|
|
41746
41765
|
"camera-disabled",
|
|
@@ -50789,7 +50808,10 @@ method(StorageMigrationInputSchema, StorageMigrationPlanSchema, { auth: "admin"
|
|
|
50789
50808
|
}), method(object({ jobId: string().optional() }), StorageMigrationJobSchema.nullable(), { auth: "admin" }), method(object({ jobId: string() }), object({ cancelled: boolean() }), {
|
|
50790
50809
|
kind: "mutation",
|
|
50791
50810
|
auth: "admin"
|
|
50792
|
-
}), method(object({}), array(StorageMigrationMoverSchema).readonly(), { auth: "admin" }), method(object({
|
|
50811
|
+
}), method(object({}), array(StorageMigrationMoverSchema).readonly(), { auth: "admin" }), method(object({ locationIds: array(string()).readonly() }), object({
|
|
50812
|
+
clear: boolean(),
|
|
50813
|
+
repointLocationId: string().optional()
|
|
50814
|
+
}), { auth: "admin" }), method(object({}), array(StorageMigrationResidueSchema).readonly(), { auth: "admin" }), method(StorageMigrationDrainInputSchema, object({ jobId: string() }), {
|
|
50793
50815
|
kind: "mutation",
|
|
50794
50816
|
auth: "admin"
|
|
50795
50817
|
}), method(StorageCleanupInputSchema, object({ jobId: string() }), {
|
|
@@ -54236,6 +54258,11 @@ object({
|
|
|
54236
54258
|
*
|
|
54237
54259
|
* `kind: 'poll'` — cloud REST APIs typically have no push channel; the
|
|
54238
54260
|
* provider refreshes the slice on an interval and eagerly after commands.
|
|
54261
|
+
*
|
|
54262
|
+
* UNKNOWN IS NOT OFF. Every field the appliance reports separately is
|
|
54263
|
+
* nullable: `null` means "not known right now" (the appliance has not said,
|
|
54264
|
+
* the link is down, or the description does not carry it) and is never
|
|
54265
|
+
* rendered or exported as `false` / `0`. `availability` says why.
|
|
54239
54266
|
*/
|
|
54240
54267
|
var DishwasherStateSchema = _enum([
|
|
54241
54268
|
"idle",
|
|
@@ -54245,112 +54272,227 @@ var DishwasherStateSchema = _enum([
|
|
|
54245
54272
|
"error",
|
|
54246
54273
|
"unavailable"
|
|
54247
54274
|
]);
|
|
54275
|
+
/**
|
|
54276
|
+
* The appliance's own operation state, uncollapsed. `state` above is the coarse
|
|
54277
|
+
* view for compact surfaces; this is what the appliance said.
|
|
54278
|
+
*/
|
|
54279
|
+
var DishwasherOperationStateSchema = _enum([
|
|
54280
|
+
"Inactive",
|
|
54281
|
+
"Ready",
|
|
54282
|
+
"DelayedStart",
|
|
54283
|
+
"Run",
|
|
54284
|
+
"Pause",
|
|
54285
|
+
"ActionRequired",
|
|
54286
|
+
"Finished",
|
|
54287
|
+
"Error",
|
|
54288
|
+
"Aborting"
|
|
54289
|
+
]);
|
|
54290
|
+
/**
|
|
54291
|
+
* Why fields may be `null`:
|
|
54292
|
+
* - `available` — the link is up and the description is loaded;
|
|
54293
|
+
* - `offline` — the local link is down (values are unknown, not last-known);
|
|
54294
|
+
* - `description-missing` — the link is up but the appliance's description could not
|
|
54295
|
+
* be loaded, so its values cannot be decoded.
|
|
54296
|
+
*/
|
|
54297
|
+
var DishwasherAvailabilitySchema = _enum([
|
|
54298
|
+
"available",
|
|
54299
|
+
"offline",
|
|
54300
|
+
"description-missing"
|
|
54301
|
+
]);
|
|
54248
54302
|
var DishwasherConsumableLevelSchema = _enum([
|
|
54249
54303
|
"ok",
|
|
54250
54304
|
"low",
|
|
54251
54305
|
"empty"
|
|
54252
54306
|
]);
|
|
54253
54307
|
object({
|
|
54308
|
+
availability: DishwasherAvailabilitySchema,
|
|
54309
|
+
/** Coarse state for compact surfaces; `unavailable` whenever the appliance state is not known. */
|
|
54254
54310
|
state: DishwasherStateSchema,
|
|
54255
|
-
/**
|
|
54311
|
+
/** The appliance's operation state as reported; null when not known. */
|
|
54312
|
+
operationState: DishwasherOperationStateSchema.nullable(),
|
|
54313
|
+
/** Feature key of the ACTIVE (running) program, or null when none runs / not known. */
|
|
54256
54314
|
program: string().nullable(),
|
|
54257
|
-
/**
|
|
54315
|
+
/** Feature key of the SELECTED program (what Start would run), or null when none / not known. */
|
|
54316
|
+
selectedProgram: string().nullable(),
|
|
54317
|
+
/** Feature keys of the programs the appliance currently offers — drives the UI selector. */
|
|
54258
54318
|
availablePrograms: array(string()),
|
|
54259
|
-
/**
|
|
54260
|
-
|
|
54319
|
+
/** Seconds remaining on the active cycle, or null when not running / not known. */
|
|
54320
|
+
remainingSeconds: number().int().nonnegative().nullable(),
|
|
54321
|
+
/** Seconds the delayed start is set to (time until the cycle starts), or null. */
|
|
54322
|
+
delayedStartSeconds: number().int().nonnegative().nullable(),
|
|
54261
54323
|
/** Cycle completion 0..100, or null when not applicable. */
|
|
54262
54324
|
progressPercent: number().min(0).max(100).nullable(),
|
|
54263
|
-
/** True when the door is reported open. */
|
|
54264
|
-
doorOpen: boolean(),
|
|
54265
|
-
/** True when
|
|
54266
|
-
|
|
54267
|
-
/**
|
|
54268
|
-
|
|
54325
|
+
/** True when the door is reported open; null when the door state is not known. */
|
|
54326
|
+
doorOpen: boolean().nullable(),
|
|
54327
|
+
/** True when the door is latched (locked) during a cycle; null when not reported. */
|
|
54328
|
+
doorLocked: boolean().nullable(),
|
|
54329
|
+
/** True when remote start is allowed (door closed, power on, etc.); null when not known. */
|
|
54330
|
+
remoteStartAllowed: boolean().nullable(),
|
|
54331
|
+
/** True when the appliance accepts remote control now; null when not known. */
|
|
54332
|
+
remoteControlActive: boolean().nullable(),
|
|
54333
|
+
/** True while somebody operates the appliance at its panel; null when not reported. */
|
|
54334
|
+
localControlActive: boolean().nullable(),
|
|
54335
|
+
/** Main power / switched-on state; null when not known. */
|
|
54336
|
+
powerOn: boolean().nullable(),
|
|
54337
|
+
/** The raw power state (`On`, `Off`, `Standby`, …); null when not known. */
|
|
54338
|
+
powerState: string().nullable(),
|
|
54269
54339
|
saltLevel: DishwasherConsumableLevelSchema.nullable(),
|
|
54270
54340
|
rinseAidLevel: DishwasherConsumableLevelSchema.nullable(),
|
|
54271
|
-
|
|
54272
|
-
|
|
54341
|
+
/** Option states: null when the appliance does not expose the option or has not said. */
|
|
54342
|
+
halfLoad: boolean().nullable(),
|
|
54343
|
+
hygienePlus: boolean().nullable(),
|
|
54273
54344
|
/** Extra dry option when the appliance exposes it. */
|
|
54274
|
-
extraDry: boolean(),
|
|
54345
|
+
extraDry: boolean().nullable(),
|
|
54275
54346
|
/** Intensive zone (lower basket) when the appliance exposes it. */
|
|
54276
|
-
intensiveZone: boolean(),
|
|
54347
|
+
intensiveZone: boolean().nullable(),
|
|
54277
54348
|
/** VarioSpeed / VarioSpeed+ when the appliance exposes it. */
|
|
54278
|
-
varioSpeedPlus: boolean(),
|
|
54279
|
-
/** Child lock (controls disabled on the appliance). */
|
|
54280
|
-
childLock: boolean(),
|
|
54349
|
+
varioSpeedPlus: boolean().nullable(),
|
|
54350
|
+
/** Child lock (controls disabled on the appliance); null when not known. */
|
|
54351
|
+
childLock: boolean().nullable(),
|
|
54352
|
+
/** Feature keys of the events currently raised (salt low, rinse aid low, program finished, …). */
|
|
54353
|
+
activeEvents: array(string()),
|
|
54354
|
+
/** Numeric error code when the appliance reports one; null otherwise. */
|
|
54281
54355
|
errorCode: number().nullable(),
|
|
54356
|
+
/** Name of the raised alert-level event while the appliance is in error; null otherwise. */
|
|
54282
54357
|
errorLabel: string().nullable(),
|
|
54358
|
+
/** Ms epoch of the last value received from the appliance; 0 = never. */
|
|
54283
54359
|
lastFetchedAt: number()
|
|
54284
54360
|
});
|
|
54285
|
-
|
|
54361
|
+
var DeviceIdSchema = number().int().nonnegative();
|
|
54362
|
+
/** A value a program option or setting can take. */
|
|
54363
|
+
var DishwasherValueSchema = union([
|
|
54364
|
+
boolean(),
|
|
54365
|
+
string(),
|
|
54366
|
+
number()
|
|
54367
|
+
]);
|
|
54368
|
+
var DishwasherAccessSchema = _enum([
|
|
54369
|
+
"none",
|
|
54370
|
+
"read",
|
|
54371
|
+
"readWrite",
|
|
54372
|
+
"writeOnly",
|
|
54373
|
+
"readStatic"
|
|
54374
|
+
]);
|
|
54375
|
+
/**
|
|
54376
|
+
* One option or setting the appliance declares, with the constraints its description
|
|
54377
|
+
* gives. A `readWrite` descriptor that is `available` is what `setOption` accepts.
|
|
54378
|
+
*/
|
|
54379
|
+
var DishwasherOptionDescriptorSchema = object({
|
|
54380
|
+
/** Feature key (`Dishcare.Dishwasher.Option.ExtraDry`). */
|
|
54381
|
+
key: string(),
|
|
54382
|
+
/** Last segment of the key, for display. */
|
|
54383
|
+
name: string(),
|
|
54384
|
+
type: _enum([
|
|
54385
|
+
"boolean",
|
|
54386
|
+
"number",
|
|
54387
|
+
"enum",
|
|
54388
|
+
"string"
|
|
54389
|
+
]),
|
|
54390
|
+
access: DishwasherAccessSchema,
|
|
54391
|
+
/** The appliance reports this entity as currently available. */
|
|
54392
|
+
available: boolean(),
|
|
54393
|
+
/** Unit the description declares for a number; null when it declares none. */
|
|
54394
|
+
unit: string().nullable(),
|
|
54395
|
+
min: number().nullable(),
|
|
54396
|
+
max: number().nullable(),
|
|
54397
|
+
step: number().nullable(),
|
|
54398
|
+
/** Allowed members of an enum; null for other types. */
|
|
54399
|
+
enumValues: array(string()).nullable(),
|
|
54400
|
+
defaultValue: DishwasherValueSchema.nullable()
|
|
54401
|
+
});
|
|
54402
|
+
var DishwasherProgramSchema = object({
|
|
54403
|
+
/** Feature key (`Dishcare.Dishwasher.Program.Eco50`) — what `setProgram` / `start` take. */
|
|
54404
|
+
key: string(),
|
|
54405
|
+
name: string(),
|
|
54406
|
+
/** The appliance currently offers this program. */
|
|
54407
|
+
available: boolean(),
|
|
54408
|
+
/** The options this program lists, with the program-level access / availability / default. */
|
|
54409
|
+
options: array(DishwasherOptionDescriptorSchema)
|
|
54410
|
+
});
|
|
54411
|
+
var DishwasherOptionsSchema = object({
|
|
54412
|
+
availability: DishwasherAvailabilitySchema,
|
|
54413
|
+
/** What the appliance can be told to do, from the commands its description declares. */
|
|
54414
|
+
supportsStart: boolean(),
|
|
54415
|
+
supportsPause: boolean(),
|
|
54416
|
+
supportsResume: boolean(),
|
|
54417
|
+
supportsStop: boolean(),
|
|
54418
|
+
supportsPower: boolean(),
|
|
54419
|
+
/** Every program the description lists, with its options. */
|
|
54420
|
+
programs: array(DishwasherProgramSchema),
|
|
54421
|
+
/** Every option and setting entity the description lists (programs reference these by key). */
|
|
54422
|
+
options: array(DishwasherOptionDescriptorSchema)
|
|
54423
|
+
});
|
|
54424
|
+
DeviceType.Dishwasher, method(object({
|
|
54425
|
+
deviceId: DeviceIdSchema,
|
|
54426
|
+
program: string().min(1).optional(),
|
|
54427
|
+
options: record(string(), DishwasherValueSchema).optional()
|
|
54428
|
+
}), _void(), {
|
|
54286
54429
|
kind: "mutation",
|
|
54287
54430
|
auth: "protected"
|
|
54288
|
-
}), method(object({ deviceId:
|
|
54431
|
+
}), method(object({ deviceId: DeviceIdSchema }), _void(), {
|
|
54289
54432
|
kind: "mutation",
|
|
54290
54433
|
auth: "protected"
|
|
54291
|
-
}), method(object({ deviceId:
|
|
54434
|
+
}), method(object({ deviceId: DeviceIdSchema }), _void(), {
|
|
54435
|
+
kind: "mutation",
|
|
54436
|
+
auth: "protected"
|
|
54437
|
+
}), method(object({ deviceId: DeviceIdSchema }), _void(), {
|
|
54292
54438
|
kind: "mutation",
|
|
54293
54439
|
auth: "protected"
|
|
54294
54440
|
}), method(object({
|
|
54295
|
-
deviceId:
|
|
54441
|
+
deviceId: DeviceIdSchema,
|
|
54296
54442
|
program: string().min(1)
|
|
54297
54443
|
}), _void(), {
|
|
54298
54444
|
kind: "mutation",
|
|
54299
54445
|
auth: "protected"
|
|
54300
54446
|
}), method(object({
|
|
54301
|
-
deviceId:
|
|
54447
|
+
deviceId: DeviceIdSchema,
|
|
54302
54448
|
on: boolean()
|
|
54303
54449
|
}), _void(), {
|
|
54304
54450
|
kind: "mutation",
|
|
54305
54451
|
auth: "protected"
|
|
54306
54452
|
}), method(object({
|
|
54307
|
-
deviceId:
|
|
54453
|
+
deviceId: DeviceIdSchema,
|
|
54308
54454
|
on: boolean()
|
|
54309
54455
|
}), _void(), {
|
|
54310
54456
|
kind: "mutation",
|
|
54311
54457
|
auth: "protected"
|
|
54312
54458
|
}), method(object({
|
|
54313
|
-
deviceId:
|
|
54459
|
+
deviceId: DeviceIdSchema,
|
|
54314
54460
|
on: boolean()
|
|
54315
54461
|
}), _void(), {
|
|
54316
54462
|
kind: "mutation",
|
|
54317
54463
|
auth: "protected"
|
|
54318
54464
|
}), method(object({
|
|
54319
|
-
deviceId:
|
|
54465
|
+
deviceId: DeviceIdSchema,
|
|
54320
54466
|
on: boolean()
|
|
54321
54467
|
}), _void(), {
|
|
54322
54468
|
kind: "mutation",
|
|
54323
54469
|
auth: "protected"
|
|
54324
54470
|
}), method(object({
|
|
54325
|
-
deviceId:
|
|
54471
|
+
deviceId: DeviceIdSchema,
|
|
54326
54472
|
on: boolean()
|
|
54327
54473
|
}), _void(), {
|
|
54328
54474
|
kind: "mutation",
|
|
54329
54475
|
auth: "protected"
|
|
54330
54476
|
}), method(object({
|
|
54331
|
-
deviceId:
|
|
54477
|
+
deviceId: DeviceIdSchema,
|
|
54332
54478
|
on: boolean()
|
|
54333
54479
|
}), _void(), {
|
|
54334
54480
|
kind: "mutation",
|
|
54335
54481
|
auth: "protected"
|
|
54336
54482
|
}), method(object({
|
|
54337
|
-
deviceId:
|
|
54483
|
+
deviceId: DeviceIdSchema,
|
|
54338
54484
|
on: boolean()
|
|
54339
54485
|
}), _void(), {
|
|
54340
54486
|
kind: "mutation",
|
|
54341
54487
|
auth: "protected"
|
|
54342
54488
|
}), method(object({
|
|
54343
|
-
deviceId:
|
|
54489
|
+
deviceId: DeviceIdSchema,
|
|
54344
54490
|
key: string().min(1),
|
|
54345
|
-
value:
|
|
54346
|
-
boolean(),
|
|
54347
|
-
string(),
|
|
54348
|
-
number()
|
|
54349
|
-
])
|
|
54491
|
+
value: DishwasherValueSchema
|
|
54350
54492
|
}), _void(), {
|
|
54351
54493
|
kind: "mutation",
|
|
54352
54494
|
auth: "protected"
|
|
54353
|
-
});
|
|
54495
|
+
}), method(object({ deviceId: DeviceIdSchema }), DishwasherOptionsSchema, { auth: "protected" });
|
|
54354
54496
|
object({
|
|
54355
54497
|
/** Ms epoch of the last press. null = never observed since this provider started. */
|
|
54356
54498
|
lastPressedAt: number().nullable(),
|
|
@@ -64417,6 +64559,12 @@ Object.freeze({
|
|
|
64417
64559
|
addonId: null,
|
|
64418
64560
|
access: "view"
|
|
64419
64561
|
},
|
|
64562
|
+
"dishwasher.getOptions": {
|
|
64563
|
+
capName: "dishwasher",
|
|
64564
|
+
capScope: "device",
|
|
64565
|
+
addonId: null,
|
|
64566
|
+
access: "view"
|
|
64567
|
+
},
|
|
64420
64568
|
"dishwasher.getStatus": {
|
|
64421
64569
|
capName: "dishwasher",
|
|
64422
64570
|
capScope: "device",
|
|
@@ -64429,6 +64577,12 @@ Object.freeze({
|
|
|
64429
64577
|
addonId: null,
|
|
64430
64578
|
access: "create"
|
|
64431
64579
|
},
|
|
64580
|
+
"dishwasher.resume": {
|
|
64581
|
+
capName: "dishwasher",
|
|
64582
|
+
capScope: "device",
|
|
64583
|
+
addonId: null,
|
|
64584
|
+
access: "create"
|
|
64585
|
+
},
|
|
64432
64586
|
"dishwasher.setChildLock": {
|
|
64433
64587
|
capName: "dishwasher",
|
|
64434
64588
|
capScope: "device",
|
|
@@ -68929,6 +69083,12 @@ Object.freeze({
|
|
|
68929
69083
|
addonId: null,
|
|
68930
69084
|
access: "view"
|
|
68931
69085
|
},
|
|
69086
|
+
"storageMigration.moverClearance": {
|
|
69087
|
+
capName: "storage-migration",
|
|
69088
|
+
capScope: "system",
|
|
69089
|
+
addonId: null,
|
|
69090
|
+
access: "view"
|
|
69091
|
+
},
|
|
68932
69092
|
"storageMigration.movers": {
|
|
68933
69093
|
capName: "storage-migration",
|
|
68934
69094
|
capScope: "system",
|
|
@@ -71122,6 +71282,11 @@ Object.freeze({
|
|
|
71122
71282
|
form: "single",
|
|
71123
71283
|
optional: false
|
|
71124
71284
|
}],
|
|
71285
|
+
"dishwasher.getOptions": [{
|
|
71286
|
+
name: "deviceId",
|
|
71287
|
+
form: "single",
|
|
71288
|
+
optional: false
|
|
71289
|
+
}],
|
|
71125
71290
|
"dishwasher.getStatus": [{
|
|
71126
71291
|
name: "deviceId",
|
|
71127
71292
|
form: "single",
|
|
@@ -71132,6 +71297,11 @@ Object.freeze({
|
|
|
71132
71297
|
form: "single",
|
|
71133
71298
|
optional: false
|
|
71134
71299
|
}],
|
|
71300
|
+
"dishwasher.resume": [{
|
|
71301
|
+
name: "deviceId",
|
|
71302
|
+
form: "single",
|
|
71303
|
+
optional: false
|
|
71304
|
+
}],
|
|
71135
71305
|
"dishwasher.setChildLock": [{
|
|
71136
71306
|
name: "deviceId",
|
|
71137
71307
|
form: "single",
|
|
@@ -73218,6 +73388,9 @@ new Map(Object.entries({
|
|
|
73218
73388
|
"wrapper-update-available": "system",
|
|
73219
73389
|
"backup-completed": "system",
|
|
73220
73390
|
"export-completed": "system",
|
|
73391
|
+
"alert-critical": "system",
|
|
73392
|
+
"alert-error": "system",
|
|
73393
|
+
"alert-critical-resolved": "system",
|
|
73221
73394
|
"storage-location-low": "system",
|
|
73222
73395
|
"storage-location-critical": "system",
|
|
73223
73396
|
"storage-location-ok": "system",
|
|
@@ -73342,6 +73515,16 @@ var NC_SYSTEM_EVENT_KIND_GROUP_SPECS = [
|
|
|
73342
73515
|
"storage-location-ok"
|
|
73343
73516
|
]
|
|
73344
73517
|
},
|
|
73518
|
+
{
|
|
73519
|
+
id: "alerts",
|
|
73520
|
+
family: "system",
|
|
73521
|
+
label: "Alerts",
|
|
73522
|
+
kinds: [
|
|
73523
|
+
"alert-critical",
|
|
73524
|
+
"alert-error",
|
|
73525
|
+
"alert-critical-resolved"
|
|
73526
|
+
]
|
|
73527
|
+
},
|
|
73345
73528
|
{
|
|
73346
73529
|
id: "alarm",
|
|
73347
73530
|
family: "alarm",
|
|
@@ -73386,6 +73569,21 @@ var NC_SENSOR_RAISED_FIELD_BY_KIND = Object.freeze(Object.fromEntries(Object.ent
|
|
|
73386
73569
|
return [[descriptor.kind, field]];
|
|
73387
73570
|
})));
|
|
73388
73571
|
Object.freeze(Object.keys(NC_SENSOR_RAISED_FIELD_BY_KIND));
|
|
73572
|
+
object({
|
|
73573
|
+
phase: _enum(["raised", "resolved"]),
|
|
73574
|
+
episodeId: string().min(1),
|
|
73575
|
+
alertId: string().min(1),
|
|
73576
|
+
severity: AlertSeveritySchema,
|
|
73577
|
+
category: string(),
|
|
73578
|
+
title: string(),
|
|
73579
|
+
message: string(),
|
|
73580
|
+
sourceType: string().optional(),
|
|
73581
|
+
sourceId: string().optional(),
|
|
73582
|
+
nodeId: string().optional(),
|
|
73583
|
+
/** The alert's own action link (where the operator acts on it), when it has one. */
|
|
73584
|
+
actionUrl: string().optional(),
|
|
73585
|
+
at: number()
|
|
73586
|
+
});
|
|
73389
73587
|
var RULE_BODY_ONLY = ["body"];
|
|
73390
73588
|
var RULE_TEXT = ["title", "body"];
|
|
73391
73589
|
var BATTERY = ["device-battery-low", "device-battery-normal"];
|
|
@@ -73395,6 +73593,11 @@ var TANK = [
|
|
|
73395
73593
|
"device-tank-full",
|
|
73396
73594
|
"device-tank-normal"
|
|
73397
73595
|
];
|
|
73596
|
+
var ALERT_EPISODE = [
|
|
73597
|
+
"alert-critical",
|
|
73598
|
+
"alert-error",
|
|
73599
|
+
"alert-critical-resolved"
|
|
73600
|
+
];
|
|
73398
73601
|
var UPDATES = [
|
|
73399
73602
|
"addon-update-available",
|
|
73400
73603
|
"server-update-available",
|
|
@@ -73587,14 +73790,14 @@ var STATE_SUMMARY_VARS = [
|
|
|
73587
73790
|
([...RULE_TEXT], [...CONSUMABLE]),
|
|
73588
73791
|
([...RULE_TEXT], [...TANK]),
|
|
73589
73792
|
[...RULE_TEXT],
|
|
73590
|
-
([...RULE_TEXT], [...UPDATES]),
|
|
73591
|
-
([...RULE_TEXT], [...UPDATES]),
|
|
73592
|
-
[...RULE_TEXT],
|
|
73793
|
+
([...RULE_TEXT], [...UPDATES, ...ALERT_EPISODE]),
|
|
73794
|
+
([...RULE_TEXT], [...UPDATES, ...ALERT_EPISODE]),
|
|
73593
73795
|
[...RULE_TEXT],
|
|
73594
73796
|
[...RULE_TEXT],
|
|
73595
73797
|
[...RULE_TEXT],
|
|
73596
73798
|
[...RULE_TEXT],
|
|
73597
73799
|
[...RULE_TEXT],
|
|
73800
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
73598
73801
|
[...RULE_TEXT],
|
|
73599
73802
|
[...RULE_TEXT],
|
|
73600
73803
|
[...RULE_TEXT],
|
|
@@ -73612,7 +73815,11 @@ var STATE_SUMMARY_VARS = [
|
|
|
73612
73815
|
[...RULE_TEXT],
|
|
73613
73816
|
[...RULE_TEXT],
|
|
73614
73817
|
[...RULE_TEXT],
|
|
73615
|
-
[...RULE_TEXT],
|
|
73818
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
73819
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
73820
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
73821
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
73822
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
73616
73823
|
[...RULE_TEXT],
|
|
73617
73824
|
[...RULE_TEXT],
|
|
73618
73825
|
[...RULE_TEXT],
|
|
@@ -73,7 +73,7 @@ function createApiDeviceGateway(deps) {
|
|
|
73
73
|
};
|
|
74
74
|
}
|
|
75
75
|
//#endregion
|
|
76
|
-
//#region ../types/dist/event-category-
|
|
76
|
+
//#region ../types/dist/event-category-DOl51-Ij.mjs
|
|
77
77
|
var EventCategory = /* @__PURE__ */ function(EventCategory) {
|
|
78
78
|
EventCategory["SystemBoot"] = "system.boot";
|
|
79
79
|
EventCategory["SystemAddonsReady"] = "system.addons-ready";
|
|
@@ -152,9 +152,18 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
|
|
|
152
152
|
/**
|
|
153
153
|
* The node's one-shot runner boot check (D877): planned runners against the
|
|
154
154
|
* process service, `degraded` when any is failed, refused or missing. The
|
|
155
|
-
* alert centre turns it into one
|
|
155
|
+
* alert centre turns it into one critical alert.
|
|
156
156
|
*/
|
|
157
157
|
EventCategory["SystemRunnerCheck"] = "system.runner-check";
|
|
158
|
+
/**
|
|
159
|
+
* An alert EPISODE opened or closed, emitted by the alert centre for alerts
|
|
160
|
+
* of severity `critical` or `error` (`AlertEpisodePayload`). The alert
|
|
161
|
+
* centre sends no notification of its own: Notification Center turns this
|
|
162
|
+
* into the `alert-critical` / `alert-error` / `alert-critical-resolved`
|
|
163
|
+
* system-event kinds, and reconciles from the alerts store because a bus
|
|
164
|
+
* event may be dropped (D8, D11).
|
|
165
|
+
*/
|
|
166
|
+
EventCategory["AlertEpisode"] = "alert.episode";
|
|
158
167
|
EventCategory["AddonError"] = "addon.error";
|
|
159
168
|
EventCategory["AddonPageReady"] = "addon.page-ready";
|
|
160
169
|
EventCategory["AddonWidgetReady"] = "addon.widget-ready";
|
|
@@ -5479,7 +5488,7 @@ var ZodIssueCode = {
|
|
|
5479
5488
|
var ZodFirstPartyTypeKind;
|
|
5480
5489
|
ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
|
|
5481
5490
|
//#endregion
|
|
5482
|
-
//#region ../types/dist/sleep-
|
|
5491
|
+
//#region ../types/dist/sleep-BxjU_fJM.mjs
|
|
5483
5492
|
/**
|
|
5484
5493
|
* The audio chunk plane's byte format, and the ONE expansion from a coded
|
|
5485
5494
|
* window to float samples (D455).
|
|
@@ -13336,7 +13345,14 @@ var AlertSeveritySchema = _enum([
|
|
|
13336
13345
|
]);
|
|
13337
13346
|
var AlertActionSchema = object({
|
|
13338
13347
|
label: string(),
|
|
13339
|
-
href: string().optional()
|
|
13348
|
+
href: string().optional(),
|
|
13349
|
+
/**
|
|
13350
|
+
* How `href` is followed. Absent / `app`: an admin-ui route (client-side).
|
|
13351
|
+
* `server`: a route the HUB serves (an addon HTTP route such as an OAuth
|
|
13352
|
+
* start) — the browser must leave the SPA with a full navigation, because
|
|
13353
|
+
* the SPA has no such route and would bounce to the home page.
|
|
13354
|
+
*/
|
|
13355
|
+
navigation: _enum(["app", "server"]).optional()
|
|
13340
13356
|
});
|
|
13341
13357
|
var AlertStatusSchema = _enum([
|
|
13342
13358
|
"active",
|
|
@@ -41737,6 +41753,9 @@ var NcSystemEventKindSchema = _enum([
|
|
|
41737
41753
|
"server-updated",
|
|
41738
41754
|
"export-completed",
|
|
41739
41755
|
"backup-completed",
|
|
41756
|
+
"alert-critical",
|
|
41757
|
+
"alert-error",
|
|
41758
|
+
"alert-critical-resolved",
|
|
41740
41759
|
"camera-online",
|
|
41741
41760
|
"camera-offline",
|
|
41742
41761
|
"camera-disabled",
|
|
@@ -50785,7 +50804,10 @@ method(StorageMigrationInputSchema, StorageMigrationPlanSchema, { auth: "admin"
|
|
|
50785
50804
|
}), method(object({ jobId: string().optional() }), StorageMigrationJobSchema.nullable(), { auth: "admin" }), method(object({ jobId: string() }), object({ cancelled: boolean() }), {
|
|
50786
50805
|
kind: "mutation",
|
|
50787
50806
|
auth: "admin"
|
|
50788
|
-
}), method(object({}), array(StorageMigrationMoverSchema).readonly(), { auth: "admin" }), method(object({
|
|
50807
|
+
}), method(object({}), array(StorageMigrationMoverSchema).readonly(), { auth: "admin" }), method(object({ locationIds: array(string()).readonly() }), object({
|
|
50808
|
+
clear: boolean(),
|
|
50809
|
+
repointLocationId: string().optional()
|
|
50810
|
+
}), { auth: "admin" }), method(object({}), array(StorageMigrationResidueSchema).readonly(), { auth: "admin" }), method(StorageMigrationDrainInputSchema, object({ jobId: string() }), {
|
|
50789
50811
|
kind: "mutation",
|
|
50790
50812
|
auth: "admin"
|
|
50791
50813
|
}), method(StorageCleanupInputSchema, object({ jobId: string() }), {
|
|
@@ -54232,6 +54254,11 @@ object({
|
|
|
54232
54254
|
*
|
|
54233
54255
|
* `kind: 'poll'` — cloud REST APIs typically have no push channel; the
|
|
54234
54256
|
* provider refreshes the slice on an interval and eagerly after commands.
|
|
54257
|
+
*
|
|
54258
|
+
* UNKNOWN IS NOT OFF. Every field the appliance reports separately is
|
|
54259
|
+
* nullable: `null` means "not known right now" (the appliance has not said,
|
|
54260
|
+
* the link is down, or the description does not carry it) and is never
|
|
54261
|
+
* rendered or exported as `false` / `0`. `availability` says why.
|
|
54235
54262
|
*/
|
|
54236
54263
|
var DishwasherStateSchema = _enum([
|
|
54237
54264
|
"idle",
|
|
@@ -54241,112 +54268,227 @@ var DishwasherStateSchema = _enum([
|
|
|
54241
54268
|
"error",
|
|
54242
54269
|
"unavailable"
|
|
54243
54270
|
]);
|
|
54271
|
+
/**
|
|
54272
|
+
* The appliance's own operation state, uncollapsed. `state` above is the coarse
|
|
54273
|
+
* view for compact surfaces; this is what the appliance said.
|
|
54274
|
+
*/
|
|
54275
|
+
var DishwasherOperationStateSchema = _enum([
|
|
54276
|
+
"Inactive",
|
|
54277
|
+
"Ready",
|
|
54278
|
+
"DelayedStart",
|
|
54279
|
+
"Run",
|
|
54280
|
+
"Pause",
|
|
54281
|
+
"ActionRequired",
|
|
54282
|
+
"Finished",
|
|
54283
|
+
"Error",
|
|
54284
|
+
"Aborting"
|
|
54285
|
+
]);
|
|
54286
|
+
/**
|
|
54287
|
+
* Why fields may be `null`:
|
|
54288
|
+
* - `available` — the link is up and the description is loaded;
|
|
54289
|
+
* - `offline` — the local link is down (values are unknown, not last-known);
|
|
54290
|
+
* - `description-missing` — the link is up but the appliance's description could not
|
|
54291
|
+
* be loaded, so its values cannot be decoded.
|
|
54292
|
+
*/
|
|
54293
|
+
var DishwasherAvailabilitySchema = _enum([
|
|
54294
|
+
"available",
|
|
54295
|
+
"offline",
|
|
54296
|
+
"description-missing"
|
|
54297
|
+
]);
|
|
54244
54298
|
var DishwasherConsumableLevelSchema = _enum([
|
|
54245
54299
|
"ok",
|
|
54246
54300
|
"low",
|
|
54247
54301
|
"empty"
|
|
54248
54302
|
]);
|
|
54249
54303
|
object({
|
|
54304
|
+
availability: DishwasherAvailabilitySchema,
|
|
54305
|
+
/** Coarse state for compact surfaces; `unavailable` whenever the appliance state is not known. */
|
|
54250
54306
|
state: DishwasherStateSchema,
|
|
54251
|
-
/**
|
|
54307
|
+
/** The appliance's operation state as reported; null when not known. */
|
|
54308
|
+
operationState: DishwasherOperationStateSchema.nullable(),
|
|
54309
|
+
/** Feature key of the ACTIVE (running) program, or null when none runs / not known. */
|
|
54252
54310
|
program: string().nullable(),
|
|
54253
|
-
/**
|
|
54311
|
+
/** Feature key of the SELECTED program (what Start would run), or null when none / not known. */
|
|
54312
|
+
selectedProgram: string().nullable(),
|
|
54313
|
+
/** Feature keys of the programs the appliance currently offers — drives the UI selector. */
|
|
54254
54314
|
availablePrograms: array(string()),
|
|
54255
|
-
/**
|
|
54256
|
-
|
|
54315
|
+
/** Seconds remaining on the active cycle, or null when not running / not known. */
|
|
54316
|
+
remainingSeconds: number().int().nonnegative().nullable(),
|
|
54317
|
+
/** Seconds the delayed start is set to (time until the cycle starts), or null. */
|
|
54318
|
+
delayedStartSeconds: number().int().nonnegative().nullable(),
|
|
54257
54319
|
/** Cycle completion 0..100, or null when not applicable. */
|
|
54258
54320
|
progressPercent: number().min(0).max(100).nullable(),
|
|
54259
|
-
/** True when the door is reported open. */
|
|
54260
|
-
doorOpen: boolean(),
|
|
54261
|
-
/** True when
|
|
54262
|
-
|
|
54263
|
-
/**
|
|
54264
|
-
|
|
54321
|
+
/** True when the door is reported open; null when the door state is not known. */
|
|
54322
|
+
doorOpen: boolean().nullable(),
|
|
54323
|
+
/** True when the door is latched (locked) during a cycle; null when not reported. */
|
|
54324
|
+
doorLocked: boolean().nullable(),
|
|
54325
|
+
/** True when remote start is allowed (door closed, power on, etc.); null when not known. */
|
|
54326
|
+
remoteStartAllowed: boolean().nullable(),
|
|
54327
|
+
/** True when the appliance accepts remote control now; null when not known. */
|
|
54328
|
+
remoteControlActive: boolean().nullable(),
|
|
54329
|
+
/** True while somebody operates the appliance at its panel; null when not reported. */
|
|
54330
|
+
localControlActive: boolean().nullable(),
|
|
54331
|
+
/** Main power / switched-on state; null when not known. */
|
|
54332
|
+
powerOn: boolean().nullable(),
|
|
54333
|
+
/** The raw power state (`On`, `Off`, `Standby`, …); null when not known. */
|
|
54334
|
+
powerState: string().nullable(),
|
|
54265
54335
|
saltLevel: DishwasherConsumableLevelSchema.nullable(),
|
|
54266
54336
|
rinseAidLevel: DishwasherConsumableLevelSchema.nullable(),
|
|
54267
|
-
|
|
54268
|
-
|
|
54337
|
+
/** Option states: null when the appliance does not expose the option or has not said. */
|
|
54338
|
+
halfLoad: boolean().nullable(),
|
|
54339
|
+
hygienePlus: boolean().nullable(),
|
|
54269
54340
|
/** Extra dry option when the appliance exposes it. */
|
|
54270
|
-
extraDry: boolean(),
|
|
54341
|
+
extraDry: boolean().nullable(),
|
|
54271
54342
|
/** Intensive zone (lower basket) when the appliance exposes it. */
|
|
54272
|
-
intensiveZone: boolean(),
|
|
54343
|
+
intensiveZone: boolean().nullable(),
|
|
54273
54344
|
/** VarioSpeed / VarioSpeed+ when the appliance exposes it. */
|
|
54274
|
-
varioSpeedPlus: boolean(),
|
|
54275
|
-
/** Child lock (controls disabled on the appliance). */
|
|
54276
|
-
childLock: boolean(),
|
|
54345
|
+
varioSpeedPlus: boolean().nullable(),
|
|
54346
|
+
/** Child lock (controls disabled on the appliance); null when not known. */
|
|
54347
|
+
childLock: boolean().nullable(),
|
|
54348
|
+
/** Feature keys of the events currently raised (salt low, rinse aid low, program finished, …). */
|
|
54349
|
+
activeEvents: array(string()),
|
|
54350
|
+
/** Numeric error code when the appliance reports one; null otherwise. */
|
|
54277
54351
|
errorCode: number().nullable(),
|
|
54352
|
+
/** Name of the raised alert-level event while the appliance is in error; null otherwise. */
|
|
54278
54353
|
errorLabel: string().nullable(),
|
|
54354
|
+
/** Ms epoch of the last value received from the appliance; 0 = never. */
|
|
54279
54355
|
lastFetchedAt: number()
|
|
54280
54356
|
});
|
|
54281
|
-
|
|
54357
|
+
var DeviceIdSchema = number().int().nonnegative();
|
|
54358
|
+
/** A value a program option or setting can take. */
|
|
54359
|
+
var DishwasherValueSchema = union([
|
|
54360
|
+
boolean(),
|
|
54361
|
+
string(),
|
|
54362
|
+
number()
|
|
54363
|
+
]);
|
|
54364
|
+
var DishwasherAccessSchema = _enum([
|
|
54365
|
+
"none",
|
|
54366
|
+
"read",
|
|
54367
|
+
"readWrite",
|
|
54368
|
+
"writeOnly",
|
|
54369
|
+
"readStatic"
|
|
54370
|
+
]);
|
|
54371
|
+
/**
|
|
54372
|
+
* One option or setting the appliance declares, with the constraints its description
|
|
54373
|
+
* gives. A `readWrite` descriptor that is `available` is what `setOption` accepts.
|
|
54374
|
+
*/
|
|
54375
|
+
var DishwasherOptionDescriptorSchema = object({
|
|
54376
|
+
/** Feature key (`Dishcare.Dishwasher.Option.ExtraDry`). */
|
|
54377
|
+
key: string(),
|
|
54378
|
+
/** Last segment of the key, for display. */
|
|
54379
|
+
name: string(),
|
|
54380
|
+
type: _enum([
|
|
54381
|
+
"boolean",
|
|
54382
|
+
"number",
|
|
54383
|
+
"enum",
|
|
54384
|
+
"string"
|
|
54385
|
+
]),
|
|
54386
|
+
access: DishwasherAccessSchema,
|
|
54387
|
+
/** The appliance reports this entity as currently available. */
|
|
54388
|
+
available: boolean(),
|
|
54389
|
+
/** Unit the description declares for a number; null when it declares none. */
|
|
54390
|
+
unit: string().nullable(),
|
|
54391
|
+
min: number().nullable(),
|
|
54392
|
+
max: number().nullable(),
|
|
54393
|
+
step: number().nullable(),
|
|
54394
|
+
/** Allowed members of an enum; null for other types. */
|
|
54395
|
+
enumValues: array(string()).nullable(),
|
|
54396
|
+
defaultValue: DishwasherValueSchema.nullable()
|
|
54397
|
+
});
|
|
54398
|
+
var DishwasherProgramSchema = object({
|
|
54399
|
+
/** Feature key (`Dishcare.Dishwasher.Program.Eco50`) — what `setProgram` / `start` take. */
|
|
54400
|
+
key: string(),
|
|
54401
|
+
name: string(),
|
|
54402
|
+
/** The appliance currently offers this program. */
|
|
54403
|
+
available: boolean(),
|
|
54404
|
+
/** The options this program lists, with the program-level access / availability / default. */
|
|
54405
|
+
options: array(DishwasherOptionDescriptorSchema)
|
|
54406
|
+
});
|
|
54407
|
+
var DishwasherOptionsSchema = object({
|
|
54408
|
+
availability: DishwasherAvailabilitySchema,
|
|
54409
|
+
/** What the appliance can be told to do, from the commands its description declares. */
|
|
54410
|
+
supportsStart: boolean(),
|
|
54411
|
+
supportsPause: boolean(),
|
|
54412
|
+
supportsResume: boolean(),
|
|
54413
|
+
supportsStop: boolean(),
|
|
54414
|
+
supportsPower: boolean(),
|
|
54415
|
+
/** Every program the description lists, with its options. */
|
|
54416
|
+
programs: array(DishwasherProgramSchema),
|
|
54417
|
+
/** Every option and setting entity the description lists (programs reference these by key). */
|
|
54418
|
+
options: array(DishwasherOptionDescriptorSchema)
|
|
54419
|
+
});
|
|
54420
|
+
DeviceType.Dishwasher, method(object({
|
|
54421
|
+
deviceId: DeviceIdSchema,
|
|
54422
|
+
program: string().min(1).optional(),
|
|
54423
|
+
options: record(string(), DishwasherValueSchema).optional()
|
|
54424
|
+
}), _void(), {
|
|
54282
54425
|
kind: "mutation",
|
|
54283
54426
|
auth: "protected"
|
|
54284
|
-
}), method(object({ deviceId:
|
|
54427
|
+
}), method(object({ deviceId: DeviceIdSchema }), _void(), {
|
|
54285
54428
|
kind: "mutation",
|
|
54286
54429
|
auth: "protected"
|
|
54287
|
-
}), method(object({ deviceId:
|
|
54430
|
+
}), method(object({ deviceId: DeviceIdSchema }), _void(), {
|
|
54431
|
+
kind: "mutation",
|
|
54432
|
+
auth: "protected"
|
|
54433
|
+
}), method(object({ deviceId: DeviceIdSchema }), _void(), {
|
|
54288
54434
|
kind: "mutation",
|
|
54289
54435
|
auth: "protected"
|
|
54290
54436
|
}), method(object({
|
|
54291
|
-
deviceId:
|
|
54437
|
+
deviceId: DeviceIdSchema,
|
|
54292
54438
|
program: string().min(1)
|
|
54293
54439
|
}), _void(), {
|
|
54294
54440
|
kind: "mutation",
|
|
54295
54441
|
auth: "protected"
|
|
54296
54442
|
}), method(object({
|
|
54297
|
-
deviceId:
|
|
54443
|
+
deviceId: DeviceIdSchema,
|
|
54298
54444
|
on: boolean()
|
|
54299
54445
|
}), _void(), {
|
|
54300
54446
|
kind: "mutation",
|
|
54301
54447
|
auth: "protected"
|
|
54302
54448
|
}), method(object({
|
|
54303
|
-
deviceId:
|
|
54449
|
+
deviceId: DeviceIdSchema,
|
|
54304
54450
|
on: boolean()
|
|
54305
54451
|
}), _void(), {
|
|
54306
54452
|
kind: "mutation",
|
|
54307
54453
|
auth: "protected"
|
|
54308
54454
|
}), method(object({
|
|
54309
|
-
deviceId:
|
|
54455
|
+
deviceId: DeviceIdSchema,
|
|
54310
54456
|
on: boolean()
|
|
54311
54457
|
}), _void(), {
|
|
54312
54458
|
kind: "mutation",
|
|
54313
54459
|
auth: "protected"
|
|
54314
54460
|
}), method(object({
|
|
54315
|
-
deviceId:
|
|
54461
|
+
deviceId: DeviceIdSchema,
|
|
54316
54462
|
on: boolean()
|
|
54317
54463
|
}), _void(), {
|
|
54318
54464
|
kind: "mutation",
|
|
54319
54465
|
auth: "protected"
|
|
54320
54466
|
}), method(object({
|
|
54321
|
-
deviceId:
|
|
54467
|
+
deviceId: DeviceIdSchema,
|
|
54322
54468
|
on: boolean()
|
|
54323
54469
|
}), _void(), {
|
|
54324
54470
|
kind: "mutation",
|
|
54325
54471
|
auth: "protected"
|
|
54326
54472
|
}), method(object({
|
|
54327
|
-
deviceId:
|
|
54473
|
+
deviceId: DeviceIdSchema,
|
|
54328
54474
|
on: boolean()
|
|
54329
54475
|
}), _void(), {
|
|
54330
54476
|
kind: "mutation",
|
|
54331
54477
|
auth: "protected"
|
|
54332
54478
|
}), method(object({
|
|
54333
|
-
deviceId:
|
|
54479
|
+
deviceId: DeviceIdSchema,
|
|
54334
54480
|
on: boolean()
|
|
54335
54481
|
}), _void(), {
|
|
54336
54482
|
kind: "mutation",
|
|
54337
54483
|
auth: "protected"
|
|
54338
54484
|
}), method(object({
|
|
54339
|
-
deviceId:
|
|
54485
|
+
deviceId: DeviceIdSchema,
|
|
54340
54486
|
key: string().min(1),
|
|
54341
|
-
value:
|
|
54342
|
-
boolean(),
|
|
54343
|
-
string(),
|
|
54344
|
-
number()
|
|
54345
|
-
])
|
|
54487
|
+
value: DishwasherValueSchema
|
|
54346
54488
|
}), _void(), {
|
|
54347
54489
|
kind: "mutation",
|
|
54348
54490
|
auth: "protected"
|
|
54349
|
-
});
|
|
54491
|
+
}), method(object({ deviceId: DeviceIdSchema }), DishwasherOptionsSchema, { auth: "protected" });
|
|
54350
54492
|
object({
|
|
54351
54493
|
/** Ms epoch of the last press. null = never observed since this provider started. */
|
|
54352
54494
|
lastPressedAt: number().nullable(),
|
|
@@ -64413,6 +64555,12 @@ Object.freeze({
|
|
|
64413
64555
|
addonId: null,
|
|
64414
64556
|
access: "view"
|
|
64415
64557
|
},
|
|
64558
|
+
"dishwasher.getOptions": {
|
|
64559
|
+
capName: "dishwasher",
|
|
64560
|
+
capScope: "device",
|
|
64561
|
+
addonId: null,
|
|
64562
|
+
access: "view"
|
|
64563
|
+
},
|
|
64416
64564
|
"dishwasher.getStatus": {
|
|
64417
64565
|
capName: "dishwasher",
|
|
64418
64566
|
capScope: "device",
|
|
@@ -64425,6 +64573,12 @@ Object.freeze({
|
|
|
64425
64573
|
addonId: null,
|
|
64426
64574
|
access: "create"
|
|
64427
64575
|
},
|
|
64576
|
+
"dishwasher.resume": {
|
|
64577
|
+
capName: "dishwasher",
|
|
64578
|
+
capScope: "device",
|
|
64579
|
+
addonId: null,
|
|
64580
|
+
access: "create"
|
|
64581
|
+
},
|
|
64428
64582
|
"dishwasher.setChildLock": {
|
|
64429
64583
|
capName: "dishwasher",
|
|
64430
64584
|
capScope: "device",
|
|
@@ -68925,6 +69079,12 @@ Object.freeze({
|
|
|
68925
69079
|
addonId: null,
|
|
68926
69080
|
access: "view"
|
|
68927
69081
|
},
|
|
69082
|
+
"storageMigration.moverClearance": {
|
|
69083
|
+
capName: "storage-migration",
|
|
69084
|
+
capScope: "system",
|
|
69085
|
+
addonId: null,
|
|
69086
|
+
access: "view"
|
|
69087
|
+
},
|
|
68928
69088
|
"storageMigration.movers": {
|
|
68929
69089
|
capName: "storage-migration",
|
|
68930
69090
|
capScope: "system",
|
|
@@ -71118,6 +71278,11 @@ Object.freeze({
|
|
|
71118
71278
|
form: "single",
|
|
71119
71279
|
optional: false
|
|
71120
71280
|
}],
|
|
71281
|
+
"dishwasher.getOptions": [{
|
|
71282
|
+
name: "deviceId",
|
|
71283
|
+
form: "single",
|
|
71284
|
+
optional: false
|
|
71285
|
+
}],
|
|
71121
71286
|
"dishwasher.getStatus": [{
|
|
71122
71287
|
name: "deviceId",
|
|
71123
71288
|
form: "single",
|
|
@@ -71128,6 +71293,11 @@ Object.freeze({
|
|
|
71128
71293
|
form: "single",
|
|
71129
71294
|
optional: false
|
|
71130
71295
|
}],
|
|
71296
|
+
"dishwasher.resume": [{
|
|
71297
|
+
name: "deviceId",
|
|
71298
|
+
form: "single",
|
|
71299
|
+
optional: false
|
|
71300
|
+
}],
|
|
71131
71301
|
"dishwasher.setChildLock": [{
|
|
71132
71302
|
name: "deviceId",
|
|
71133
71303
|
form: "single",
|
|
@@ -73214,6 +73384,9 @@ new Map(Object.entries({
|
|
|
73214
73384
|
"wrapper-update-available": "system",
|
|
73215
73385
|
"backup-completed": "system",
|
|
73216
73386
|
"export-completed": "system",
|
|
73387
|
+
"alert-critical": "system",
|
|
73388
|
+
"alert-error": "system",
|
|
73389
|
+
"alert-critical-resolved": "system",
|
|
73217
73390
|
"storage-location-low": "system",
|
|
73218
73391
|
"storage-location-critical": "system",
|
|
73219
73392
|
"storage-location-ok": "system",
|
|
@@ -73338,6 +73511,16 @@ var NC_SYSTEM_EVENT_KIND_GROUP_SPECS = [
|
|
|
73338
73511
|
"storage-location-ok"
|
|
73339
73512
|
]
|
|
73340
73513
|
},
|
|
73514
|
+
{
|
|
73515
|
+
id: "alerts",
|
|
73516
|
+
family: "system",
|
|
73517
|
+
label: "Alerts",
|
|
73518
|
+
kinds: [
|
|
73519
|
+
"alert-critical",
|
|
73520
|
+
"alert-error",
|
|
73521
|
+
"alert-critical-resolved"
|
|
73522
|
+
]
|
|
73523
|
+
},
|
|
73341
73524
|
{
|
|
73342
73525
|
id: "alarm",
|
|
73343
73526
|
family: "alarm",
|
|
@@ -73382,6 +73565,21 @@ var NC_SENSOR_RAISED_FIELD_BY_KIND = Object.freeze(Object.fromEntries(Object.ent
|
|
|
73382
73565
|
return [[descriptor.kind, field]];
|
|
73383
73566
|
})));
|
|
73384
73567
|
Object.freeze(Object.keys(NC_SENSOR_RAISED_FIELD_BY_KIND));
|
|
73568
|
+
object({
|
|
73569
|
+
phase: _enum(["raised", "resolved"]),
|
|
73570
|
+
episodeId: string().min(1),
|
|
73571
|
+
alertId: string().min(1),
|
|
73572
|
+
severity: AlertSeveritySchema,
|
|
73573
|
+
category: string(),
|
|
73574
|
+
title: string(),
|
|
73575
|
+
message: string(),
|
|
73576
|
+
sourceType: string().optional(),
|
|
73577
|
+
sourceId: string().optional(),
|
|
73578
|
+
nodeId: string().optional(),
|
|
73579
|
+
/** The alert's own action link (where the operator acts on it), when it has one. */
|
|
73580
|
+
actionUrl: string().optional(),
|
|
73581
|
+
at: number()
|
|
73582
|
+
});
|
|
73385
73583
|
var RULE_BODY_ONLY = ["body"];
|
|
73386
73584
|
var RULE_TEXT = ["title", "body"];
|
|
73387
73585
|
var BATTERY = ["device-battery-low", "device-battery-normal"];
|
|
@@ -73391,6 +73589,11 @@ var TANK = [
|
|
|
73391
73589
|
"device-tank-full",
|
|
73392
73590
|
"device-tank-normal"
|
|
73393
73591
|
];
|
|
73592
|
+
var ALERT_EPISODE = [
|
|
73593
|
+
"alert-critical",
|
|
73594
|
+
"alert-error",
|
|
73595
|
+
"alert-critical-resolved"
|
|
73596
|
+
];
|
|
73394
73597
|
var UPDATES = [
|
|
73395
73598
|
"addon-update-available",
|
|
73396
73599
|
"server-update-available",
|
|
@@ -73583,14 +73786,14 @@ var STATE_SUMMARY_VARS = [
|
|
|
73583
73786
|
([...RULE_TEXT], [...CONSUMABLE]),
|
|
73584
73787
|
([...RULE_TEXT], [...TANK]),
|
|
73585
73788
|
[...RULE_TEXT],
|
|
73586
|
-
([...RULE_TEXT], [...UPDATES]),
|
|
73587
|
-
([...RULE_TEXT], [...UPDATES]),
|
|
73588
|
-
[...RULE_TEXT],
|
|
73789
|
+
([...RULE_TEXT], [...UPDATES, ...ALERT_EPISODE]),
|
|
73790
|
+
([...RULE_TEXT], [...UPDATES, ...ALERT_EPISODE]),
|
|
73589
73791
|
[...RULE_TEXT],
|
|
73590
73792
|
[...RULE_TEXT],
|
|
73591
73793
|
[...RULE_TEXT],
|
|
73592
73794
|
[...RULE_TEXT],
|
|
73593
73795
|
[...RULE_TEXT],
|
|
73796
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
73594
73797
|
[...RULE_TEXT],
|
|
73595
73798
|
[...RULE_TEXT],
|
|
73596
73799
|
[...RULE_TEXT],
|
|
@@ -73608,7 +73811,11 @@ var STATE_SUMMARY_VARS = [
|
|
|
73608
73811
|
[...RULE_TEXT],
|
|
73609
73812
|
[...RULE_TEXT],
|
|
73610
73813
|
[...RULE_TEXT],
|
|
73611
|
-
[...RULE_TEXT],
|
|
73814
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
73815
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
73816
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
73817
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
73818
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
73612
73819
|
[...RULE_TEXT],
|
|
73613
73820
|
[...RULE_TEXT],
|
|
73614
73821
|
[...RULE_TEXT],
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@camstack/addon-export-google",
|
|
3
|
-
"version": "0.1.
|
|
3
|
+
"version": "0.1.95",
|
|
4
4
|
"description": "Google Home export — hub-side smart-home fulfillment (SYNC / QUERY / EXECUTE / DISCONNECT) for the non-camera fleet, served over the hub's own OAuth account link. No Google credential is stored, sent or required.",
|
|
5
5
|
"keywords": [
|
|
6
6
|
"camstack",
|