@camstack/addon-smtp-nodemailer 1.2.123 → 1.2.124
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/smtp.addon.js +251 -44
- package/dist/smtp.addon.mjs +251 -44
- package/package.json +1 -1
package/dist/smtp.addon.js
CHANGED
|
@@ -36,7 +36,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
|
|
|
36
36
|
}) : target, mod));
|
|
37
37
|
var __toCommonJS = (mod) => __hasOwnProp.call(mod, "module.exports") ? mod["module.exports"] : __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
|
38
38
|
//#endregion
|
|
39
|
-
//#region ../types/dist/event-category-
|
|
39
|
+
//#region ../types/dist/event-category-DOl51-Ij.mjs
|
|
40
40
|
var EventCategory = /* @__PURE__ */ function(EventCategory) {
|
|
41
41
|
EventCategory["SystemBoot"] = "system.boot";
|
|
42
42
|
EventCategory["SystemAddonsReady"] = "system.addons-ready";
|
|
@@ -115,9 +115,18 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
|
|
|
115
115
|
/**
|
|
116
116
|
* The node's one-shot runner boot check (D877): planned runners against the
|
|
117
117
|
* process service, `degraded` when any is failed, refused or missing. The
|
|
118
|
-
* alert centre turns it into one
|
|
118
|
+
* alert centre turns it into one critical alert.
|
|
119
119
|
*/
|
|
120
120
|
EventCategory["SystemRunnerCheck"] = "system.runner-check";
|
|
121
|
+
/**
|
|
122
|
+
* An alert EPISODE opened or closed, emitted by the alert centre for alerts
|
|
123
|
+
* of severity `critical` or `error` (`AlertEpisodePayload`). The alert
|
|
124
|
+
* centre sends no notification of its own: Notification Center turns this
|
|
125
|
+
* into the `alert-critical` / `alert-error` / `alert-critical-resolved`
|
|
126
|
+
* system-event kinds, and reconciles from the alerts store because a bus
|
|
127
|
+
* event may be dropped (D8, D11).
|
|
128
|
+
*/
|
|
129
|
+
EventCategory["AlertEpisode"] = "alert.episode";
|
|
121
130
|
EventCategory["AddonError"] = "addon.error";
|
|
122
131
|
EventCategory["AddonPageReady"] = "addon.page-ready";
|
|
123
132
|
EventCategory["AddonWidgetReady"] = "addon.widget-ready";
|
|
@@ -5442,7 +5451,7 @@ var ZodIssueCode = {
|
|
|
5442
5451
|
var ZodFirstPartyTypeKind;
|
|
5443
5452
|
ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
|
|
5444
5453
|
//#endregion
|
|
5445
|
-
//#region ../types/dist/sleep-
|
|
5454
|
+
//#region ../types/dist/sleep-BxjU_fJM.mjs
|
|
5446
5455
|
/**
|
|
5447
5456
|
* The audio chunk plane's byte format, and the ONE expansion from a coded
|
|
5448
5457
|
* window to float samples (D455).
|
|
@@ -13124,7 +13133,14 @@ var AlertSeveritySchema = _enum([
|
|
|
13124
13133
|
]);
|
|
13125
13134
|
var AlertActionSchema = object({
|
|
13126
13135
|
label: string(),
|
|
13127
|
-
href: string().optional()
|
|
13136
|
+
href: string().optional(),
|
|
13137
|
+
/**
|
|
13138
|
+
* How `href` is followed. Absent / `app`: an admin-ui route (client-side).
|
|
13139
|
+
* `server`: a route the HUB serves (an addon HTTP route such as an OAuth
|
|
13140
|
+
* start) — the browser must leave the SPA with a full navigation, because
|
|
13141
|
+
* the SPA has no such route and would bounce to the home page.
|
|
13142
|
+
*/
|
|
13143
|
+
navigation: _enum(["app", "server"]).optional()
|
|
13128
13144
|
});
|
|
13129
13145
|
var AlertStatusSchema = _enum([
|
|
13130
13146
|
"active",
|
|
@@ -41500,6 +41516,9 @@ var NcSystemEventKindSchema = _enum([
|
|
|
41500
41516
|
"server-updated",
|
|
41501
41517
|
"export-completed",
|
|
41502
41518
|
"backup-completed",
|
|
41519
|
+
"alert-critical",
|
|
41520
|
+
"alert-error",
|
|
41521
|
+
"alert-critical-resolved",
|
|
41503
41522
|
"camera-online",
|
|
41504
41523
|
"camera-offline",
|
|
41505
41524
|
"camera-disabled",
|
|
@@ -50545,7 +50564,10 @@ method(StorageMigrationInputSchema, StorageMigrationPlanSchema, { auth: "admin"
|
|
|
50545
50564
|
}), method(object({ jobId: string().optional() }), StorageMigrationJobSchema.nullable(), { auth: "admin" }), method(object({ jobId: string() }), object({ cancelled: boolean() }), {
|
|
50546
50565
|
kind: "mutation",
|
|
50547
50566
|
auth: "admin"
|
|
50548
|
-
}), method(object({}), array(StorageMigrationMoverSchema).readonly(), { auth: "admin" }), method(object({
|
|
50567
|
+
}), method(object({}), array(StorageMigrationMoverSchema).readonly(), { auth: "admin" }), method(object({ locationIds: array(string()).readonly() }), object({
|
|
50568
|
+
clear: boolean(),
|
|
50569
|
+
repointLocationId: string().optional()
|
|
50570
|
+
}), { auth: "admin" }), method(object({}), array(StorageMigrationResidueSchema).readonly(), { auth: "admin" }), method(StorageMigrationDrainInputSchema, object({ jobId: string() }), {
|
|
50549
50571
|
kind: "mutation",
|
|
50550
50572
|
auth: "admin"
|
|
50551
50573
|
}), method(StorageCleanupInputSchema, object({ jobId: string() }), {
|
|
@@ -53980,6 +54002,11 @@ object({
|
|
|
53980
54002
|
*
|
|
53981
54003
|
* `kind: 'poll'` — cloud REST APIs typically have no push channel; the
|
|
53982
54004
|
* provider refreshes the slice on an interval and eagerly after commands.
|
|
54005
|
+
*
|
|
54006
|
+
* UNKNOWN IS NOT OFF. Every field the appliance reports separately is
|
|
54007
|
+
* nullable: `null` means "not known right now" (the appliance has not said,
|
|
54008
|
+
* the link is down, or the description does not carry it) and is never
|
|
54009
|
+
* rendered or exported as `false` / `0`. `availability` says why.
|
|
53983
54010
|
*/
|
|
53984
54011
|
var DishwasherStateSchema = _enum([
|
|
53985
54012
|
"idle",
|
|
@@ -53989,112 +54016,227 @@ var DishwasherStateSchema = _enum([
|
|
|
53989
54016
|
"error",
|
|
53990
54017
|
"unavailable"
|
|
53991
54018
|
]);
|
|
54019
|
+
/**
|
|
54020
|
+
* The appliance's own operation state, uncollapsed. `state` above is the coarse
|
|
54021
|
+
* view for compact surfaces; this is what the appliance said.
|
|
54022
|
+
*/
|
|
54023
|
+
var DishwasherOperationStateSchema = _enum([
|
|
54024
|
+
"Inactive",
|
|
54025
|
+
"Ready",
|
|
54026
|
+
"DelayedStart",
|
|
54027
|
+
"Run",
|
|
54028
|
+
"Pause",
|
|
54029
|
+
"ActionRequired",
|
|
54030
|
+
"Finished",
|
|
54031
|
+
"Error",
|
|
54032
|
+
"Aborting"
|
|
54033
|
+
]);
|
|
54034
|
+
/**
|
|
54035
|
+
* Why fields may be `null`:
|
|
54036
|
+
* - `available` — the link is up and the description is loaded;
|
|
54037
|
+
* - `offline` — the local link is down (values are unknown, not last-known);
|
|
54038
|
+
* - `description-missing` — the link is up but the appliance's description could not
|
|
54039
|
+
* be loaded, so its values cannot be decoded.
|
|
54040
|
+
*/
|
|
54041
|
+
var DishwasherAvailabilitySchema = _enum([
|
|
54042
|
+
"available",
|
|
54043
|
+
"offline",
|
|
54044
|
+
"description-missing"
|
|
54045
|
+
]);
|
|
53992
54046
|
var DishwasherConsumableLevelSchema = _enum([
|
|
53993
54047
|
"ok",
|
|
53994
54048
|
"low",
|
|
53995
54049
|
"empty"
|
|
53996
54050
|
]);
|
|
53997
54051
|
object({
|
|
54052
|
+
availability: DishwasherAvailabilitySchema,
|
|
54053
|
+
/** Coarse state for compact surfaces; `unavailable` whenever the appliance state is not known. */
|
|
53998
54054
|
state: DishwasherStateSchema,
|
|
53999
|
-
/**
|
|
54055
|
+
/** The appliance's operation state as reported; null when not known. */
|
|
54056
|
+
operationState: DishwasherOperationStateSchema.nullable(),
|
|
54057
|
+
/** Feature key of the ACTIVE (running) program, or null when none runs / not known. */
|
|
54000
54058
|
program: string().nullable(),
|
|
54001
|
-
/**
|
|
54059
|
+
/** Feature key of the SELECTED program (what Start would run), or null when none / not known. */
|
|
54060
|
+
selectedProgram: string().nullable(),
|
|
54061
|
+
/** Feature keys of the programs the appliance currently offers — drives the UI selector. */
|
|
54002
54062
|
availablePrograms: array(string()),
|
|
54003
|
-
/**
|
|
54004
|
-
|
|
54063
|
+
/** Seconds remaining on the active cycle, or null when not running / not known. */
|
|
54064
|
+
remainingSeconds: number().int().nonnegative().nullable(),
|
|
54065
|
+
/** Seconds the delayed start is set to (time until the cycle starts), or null. */
|
|
54066
|
+
delayedStartSeconds: number().int().nonnegative().nullable(),
|
|
54005
54067
|
/** Cycle completion 0..100, or null when not applicable. */
|
|
54006
54068
|
progressPercent: number().min(0).max(100).nullable(),
|
|
54007
|
-
/** True when the door is reported open. */
|
|
54008
|
-
doorOpen: boolean(),
|
|
54009
|
-
/** True when
|
|
54010
|
-
|
|
54011
|
-
/**
|
|
54012
|
-
|
|
54069
|
+
/** True when the door is reported open; null when the door state is not known. */
|
|
54070
|
+
doorOpen: boolean().nullable(),
|
|
54071
|
+
/** True when the door is latched (locked) during a cycle; null when not reported. */
|
|
54072
|
+
doorLocked: boolean().nullable(),
|
|
54073
|
+
/** True when remote start is allowed (door closed, power on, etc.); null when not known. */
|
|
54074
|
+
remoteStartAllowed: boolean().nullable(),
|
|
54075
|
+
/** True when the appliance accepts remote control now; null when not known. */
|
|
54076
|
+
remoteControlActive: boolean().nullable(),
|
|
54077
|
+
/** True while somebody operates the appliance at its panel; null when not reported. */
|
|
54078
|
+
localControlActive: boolean().nullable(),
|
|
54079
|
+
/** Main power / switched-on state; null when not known. */
|
|
54080
|
+
powerOn: boolean().nullable(),
|
|
54081
|
+
/** The raw power state (`On`, `Off`, `Standby`, …); null when not known. */
|
|
54082
|
+
powerState: string().nullable(),
|
|
54013
54083
|
saltLevel: DishwasherConsumableLevelSchema.nullable(),
|
|
54014
54084
|
rinseAidLevel: DishwasherConsumableLevelSchema.nullable(),
|
|
54015
|
-
|
|
54016
|
-
|
|
54085
|
+
/** Option states: null when the appliance does not expose the option or has not said. */
|
|
54086
|
+
halfLoad: boolean().nullable(),
|
|
54087
|
+
hygienePlus: boolean().nullable(),
|
|
54017
54088
|
/** Extra dry option when the appliance exposes it. */
|
|
54018
|
-
extraDry: boolean(),
|
|
54089
|
+
extraDry: boolean().nullable(),
|
|
54019
54090
|
/** Intensive zone (lower basket) when the appliance exposes it. */
|
|
54020
|
-
intensiveZone: boolean(),
|
|
54091
|
+
intensiveZone: boolean().nullable(),
|
|
54021
54092
|
/** VarioSpeed / VarioSpeed+ when the appliance exposes it. */
|
|
54022
|
-
varioSpeedPlus: boolean(),
|
|
54023
|
-
/** Child lock (controls disabled on the appliance). */
|
|
54024
|
-
childLock: boolean(),
|
|
54093
|
+
varioSpeedPlus: boolean().nullable(),
|
|
54094
|
+
/** Child lock (controls disabled on the appliance); null when not known. */
|
|
54095
|
+
childLock: boolean().nullable(),
|
|
54096
|
+
/** Feature keys of the events currently raised (salt low, rinse aid low, program finished, …). */
|
|
54097
|
+
activeEvents: array(string()),
|
|
54098
|
+
/** Numeric error code when the appliance reports one; null otherwise. */
|
|
54025
54099
|
errorCode: number().nullable(),
|
|
54100
|
+
/** Name of the raised alert-level event while the appliance is in error; null otherwise. */
|
|
54026
54101
|
errorLabel: string().nullable(),
|
|
54102
|
+
/** Ms epoch of the last value received from the appliance; 0 = never. */
|
|
54027
54103
|
lastFetchedAt: number()
|
|
54028
54104
|
});
|
|
54029
|
-
|
|
54105
|
+
var DeviceIdSchema = number().int().nonnegative();
|
|
54106
|
+
/** A value a program option or setting can take. */
|
|
54107
|
+
var DishwasherValueSchema = union([
|
|
54108
|
+
boolean(),
|
|
54109
|
+
string(),
|
|
54110
|
+
number()
|
|
54111
|
+
]);
|
|
54112
|
+
var DishwasherAccessSchema = _enum([
|
|
54113
|
+
"none",
|
|
54114
|
+
"read",
|
|
54115
|
+
"readWrite",
|
|
54116
|
+
"writeOnly",
|
|
54117
|
+
"readStatic"
|
|
54118
|
+
]);
|
|
54119
|
+
/**
|
|
54120
|
+
* One option or setting the appliance declares, with the constraints its description
|
|
54121
|
+
* gives. A `readWrite` descriptor that is `available` is what `setOption` accepts.
|
|
54122
|
+
*/
|
|
54123
|
+
var DishwasherOptionDescriptorSchema = object({
|
|
54124
|
+
/** Feature key (`Dishcare.Dishwasher.Option.ExtraDry`). */
|
|
54125
|
+
key: string(),
|
|
54126
|
+
/** Last segment of the key, for display. */
|
|
54127
|
+
name: string(),
|
|
54128
|
+
type: _enum([
|
|
54129
|
+
"boolean",
|
|
54130
|
+
"number",
|
|
54131
|
+
"enum",
|
|
54132
|
+
"string"
|
|
54133
|
+
]),
|
|
54134
|
+
access: DishwasherAccessSchema,
|
|
54135
|
+
/** The appliance reports this entity as currently available. */
|
|
54136
|
+
available: boolean(),
|
|
54137
|
+
/** Unit the description declares for a number; null when it declares none. */
|
|
54138
|
+
unit: string().nullable(),
|
|
54139
|
+
min: number().nullable(),
|
|
54140
|
+
max: number().nullable(),
|
|
54141
|
+
step: number().nullable(),
|
|
54142
|
+
/** Allowed members of an enum; null for other types. */
|
|
54143
|
+
enumValues: array(string()).nullable(),
|
|
54144
|
+
defaultValue: DishwasherValueSchema.nullable()
|
|
54145
|
+
});
|
|
54146
|
+
var DishwasherProgramSchema = object({
|
|
54147
|
+
/** Feature key (`Dishcare.Dishwasher.Program.Eco50`) — what `setProgram` / `start` take. */
|
|
54148
|
+
key: string(),
|
|
54149
|
+
name: string(),
|
|
54150
|
+
/** The appliance currently offers this program. */
|
|
54151
|
+
available: boolean(),
|
|
54152
|
+
/** The options this program lists, with the program-level access / availability / default. */
|
|
54153
|
+
options: array(DishwasherOptionDescriptorSchema)
|
|
54154
|
+
});
|
|
54155
|
+
var DishwasherOptionsSchema = object({
|
|
54156
|
+
availability: DishwasherAvailabilitySchema,
|
|
54157
|
+
/** What the appliance can be told to do, from the commands its description declares. */
|
|
54158
|
+
supportsStart: boolean(),
|
|
54159
|
+
supportsPause: boolean(),
|
|
54160
|
+
supportsResume: boolean(),
|
|
54161
|
+
supportsStop: boolean(),
|
|
54162
|
+
supportsPower: boolean(),
|
|
54163
|
+
/** Every program the description lists, with its options. */
|
|
54164
|
+
programs: array(DishwasherProgramSchema),
|
|
54165
|
+
/** Every option and setting entity the description lists (programs reference these by key). */
|
|
54166
|
+
options: array(DishwasherOptionDescriptorSchema)
|
|
54167
|
+
});
|
|
54168
|
+
DeviceType.Dishwasher, method(object({
|
|
54169
|
+
deviceId: DeviceIdSchema,
|
|
54170
|
+
program: string().min(1).optional(),
|
|
54171
|
+
options: record(string(), DishwasherValueSchema).optional()
|
|
54172
|
+
}), _void(), {
|
|
54030
54173
|
kind: "mutation",
|
|
54031
54174
|
auth: "protected"
|
|
54032
|
-
}), method(object({ deviceId:
|
|
54175
|
+
}), method(object({ deviceId: DeviceIdSchema }), _void(), {
|
|
54033
54176
|
kind: "mutation",
|
|
54034
54177
|
auth: "protected"
|
|
54035
|
-
}), method(object({ deviceId:
|
|
54178
|
+
}), method(object({ deviceId: DeviceIdSchema }), _void(), {
|
|
54179
|
+
kind: "mutation",
|
|
54180
|
+
auth: "protected"
|
|
54181
|
+
}), method(object({ deviceId: DeviceIdSchema }), _void(), {
|
|
54036
54182
|
kind: "mutation",
|
|
54037
54183
|
auth: "protected"
|
|
54038
54184
|
}), method(object({
|
|
54039
|
-
deviceId:
|
|
54185
|
+
deviceId: DeviceIdSchema,
|
|
54040
54186
|
program: string().min(1)
|
|
54041
54187
|
}), _void(), {
|
|
54042
54188
|
kind: "mutation",
|
|
54043
54189
|
auth: "protected"
|
|
54044
54190
|
}), method(object({
|
|
54045
|
-
deviceId:
|
|
54191
|
+
deviceId: DeviceIdSchema,
|
|
54046
54192
|
on: boolean()
|
|
54047
54193
|
}), _void(), {
|
|
54048
54194
|
kind: "mutation",
|
|
54049
54195
|
auth: "protected"
|
|
54050
54196
|
}), method(object({
|
|
54051
|
-
deviceId:
|
|
54197
|
+
deviceId: DeviceIdSchema,
|
|
54052
54198
|
on: boolean()
|
|
54053
54199
|
}), _void(), {
|
|
54054
54200
|
kind: "mutation",
|
|
54055
54201
|
auth: "protected"
|
|
54056
54202
|
}), method(object({
|
|
54057
|
-
deviceId:
|
|
54203
|
+
deviceId: DeviceIdSchema,
|
|
54058
54204
|
on: boolean()
|
|
54059
54205
|
}), _void(), {
|
|
54060
54206
|
kind: "mutation",
|
|
54061
54207
|
auth: "protected"
|
|
54062
54208
|
}), method(object({
|
|
54063
|
-
deviceId:
|
|
54209
|
+
deviceId: DeviceIdSchema,
|
|
54064
54210
|
on: boolean()
|
|
54065
54211
|
}), _void(), {
|
|
54066
54212
|
kind: "mutation",
|
|
54067
54213
|
auth: "protected"
|
|
54068
54214
|
}), method(object({
|
|
54069
|
-
deviceId:
|
|
54215
|
+
deviceId: DeviceIdSchema,
|
|
54070
54216
|
on: boolean()
|
|
54071
54217
|
}), _void(), {
|
|
54072
54218
|
kind: "mutation",
|
|
54073
54219
|
auth: "protected"
|
|
54074
54220
|
}), method(object({
|
|
54075
|
-
deviceId:
|
|
54221
|
+
deviceId: DeviceIdSchema,
|
|
54076
54222
|
on: boolean()
|
|
54077
54223
|
}), _void(), {
|
|
54078
54224
|
kind: "mutation",
|
|
54079
54225
|
auth: "protected"
|
|
54080
54226
|
}), method(object({
|
|
54081
|
-
deviceId:
|
|
54227
|
+
deviceId: DeviceIdSchema,
|
|
54082
54228
|
on: boolean()
|
|
54083
54229
|
}), _void(), {
|
|
54084
54230
|
kind: "mutation",
|
|
54085
54231
|
auth: "protected"
|
|
54086
54232
|
}), method(object({
|
|
54087
|
-
deviceId:
|
|
54233
|
+
deviceId: DeviceIdSchema,
|
|
54088
54234
|
key: string().min(1),
|
|
54089
|
-
value:
|
|
54090
|
-
boolean(),
|
|
54091
|
-
string(),
|
|
54092
|
-
number()
|
|
54093
|
-
])
|
|
54235
|
+
value: DishwasherValueSchema
|
|
54094
54236
|
}), _void(), {
|
|
54095
54237
|
kind: "mutation",
|
|
54096
54238
|
auth: "protected"
|
|
54097
|
-
});
|
|
54239
|
+
}), method(object({ deviceId: DeviceIdSchema }), DishwasherOptionsSchema, { auth: "protected" });
|
|
54098
54240
|
object({
|
|
54099
54241
|
/** Ms epoch of the last press. null = never observed since this provider started. */
|
|
54100
54242
|
lastPressedAt: number().nullable(),
|
|
@@ -64154,6 +64296,12 @@ Object.freeze({
|
|
|
64154
64296
|
addonId: null,
|
|
64155
64297
|
access: "view"
|
|
64156
64298
|
},
|
|
64299
|
+
"dishwasher.getOptions": {
|
|
64300
|
+
capName: "dishwasher",
|
|
64301
|
+
capScope: "device",
|
|
64302
|
+
addonId: null,
|
|
64303
|
+
access: "view"
|
|
64304
|
+
},
|
|
64157
64305
|
"dishwasher.getStatus": {
|
|
64158
64306
|
capName: "dishwasher",
|
|
64159
64307
|
capScope: "device",
|
|
@@ -64166,6 +64314,12 @@ Object.freeze({
|
|
|
64166
64314
|
addonId: null,
|
|
64167
64315
|
access: "create"
|
|
64168
64316
|
},
|
|
64317
|
+
"dishwasher.resume": {
|
|
64318
|
+
capName: "dishwasher",
|
|
64319
|
+
capScope: "device",
|
|
64320
|
+
addonId: null,
|
|
64321
|
+
access: "create"
|
|
64322
|
+
},
|
|
64169
64323
|
"dishwasher.setChildLock": {
|
|
64170
64324
|
capName: "dishwasher",
|
|
64171
64325
|
capScope: "device",
|
|
@@ -68666,6 +68820,12 @@ Object.freeze({
|
|
|
68666
68820
|
addonId: null,
|
|
68667
68821
|
access: "view"
|
|
68668
68822
|
},
|
|
68823
|
+
"storageMigration.moverClearance": {
|
|
68824
|
+
capName: "storage-migration",
|
|
68825
|
+
capScope: "system",
|
|
68826
|
+
addonId: null,
|
|
68827
|
+
access: "view"
|
|
68828
|
+
},
|
|
68669
68829
|
"storageMigration.movers": {
|
|
68670
68830
|
capName: "storage-migration",
|
|
68671
68831
|
capScope: "system",
|
|
@@ -70859,6 +71019,11 @@ Object.freeze({
|
|
|
70859
71019
|
form: "single",
|
|
70860
71020
|
optional: false
|
|
70861
71021
|
}],
|
|
71022
|
+
"dishwasher.getOptions": [{
|
|
71023
|
+
name: "deviceId",
|
|
71024
|
+
form: "single",
|
|
71025
|
+
optional: false
|
|
71026
|
+
}],
|
|
70862
71027
|
"dishwasher.getStatus": [{
|
|
70863
71028
|
name: "deviceId",
|
|
70864
71029
|
form: "single",
|
|
@@ -70869,6 +71034,11 @@ Object.freeze({
|
|
|
70869
71034
|
form: "single",
|
|
70870
71035
|
optional: false
|
|
70871
71036
|
}],
|
|
71037
|
+
"dishwasher.resume": [{
|
|
71038
|
+
name: "deviceId",
|
|
71039
|
+
form: "single",
|
|
71040
|
+
optional: false
|
|
71041
|
+
}],
|
|
70872
71042
|
"dishwasher.setChildLock": [{
|
|
70873
71043
|
name: "deviceId",
|
|
70874
71044
|
form: "single",
|
|
@@ -72955,6 +73125,9 @@ new Map(Object.entries({
|
|
|
72955
73125
|
"wrapper-update-available": "system",
|
|
72956
73126
|
"backup-completed": "system",
|
|
72957
73127
|
"export-completed": "system",
|
|
73128
|
+
"alert-critical": "system",
|
|
73129
|
+
"alert-error": "system",
|
|
73130
|
+
"alert-critical-resolved": "system",
|
|
72958
73131
|
"storage-location-low": "system",
|
|
72959
73132
|
"storage-location-critical": "system",
|
|
72960
73133
|
"storage-location-ok": "system",
|
|
@@ -73079,6 +73252,16 @@ var NC_SYSTEM_EVENT_KIND_GROUP_SPECS = [
|
|
|
73079
73252
|
"storage-location-ok"
|
|
73080
73253
|
]
|
|
73081
73254
|
},
|
|
73255
|
+
{
|
|
73256
|
+
id: "alerts",
|
|
73257
|
+
family: "system",
|
|
73258
|
+
label: "Alerts",
|
|
73259
|
+
kinds: [
|
|
73260
|
+
"alert-critical",
|
|
73261
|
+
"alert-error",
|
|
73262
|
+
"alert-critical-resolved"
|
|
73263
|
+
]
|
|
73264
|
+
},
|
|
73082
73265
|
{
|
|
73083
73266
|
id: "alarm",
|
|
73084
73267
|
family: "alarm",
|
|
@@ -73123,6 +73306,21 @@ var NC_SENSOR_RAISED_FIELD_BY_KIND = Object.freeze(Object.fromEntries(Object.ent
|
|
|
73123
73306
|
return [[descriptor.kind, field]];
|
|
73124
73307
|
})));
|
|
73125
73308
|
Object.freeze(Object.keys(NC_SENSOR_RAISED_FIELD_BY_KIND));
|
|
73309
|
+
object({
|
|
73310
|
+
phase: _enum(["raised", "resolved"]),
|
|
73311
|
+
episodeId: string().min(1),
|
|
73312
|
+
alertId: string().min(1),
|
|
73313
|
+
severity: AlertSeveritySchema,
|
|
73314
|
+
category: string(),
|
|
73315
|
+
title: string(),
|
|
73316
|
+
message: string(),
|
|
73317
|
+
sourceType: string().optional(),
|
|
73318
|
+
sourceId: string().optional(),
|
|
73319
|
+
nodeId: string().optional(),
|
|
73320
|
+
/** The alert's own action link (where the operator acts on it), when it has one. */
|
|
73321
|
+
actionUrl: string().optional(),
|
|
73322
|
+
at: number()
|
|
73323
|
+
});
|
|
73126
73324
|
var RULE_BODY_ONLY = ["body"];
|
|
73127
73325
|
var RULE_TEXT = ["title", "body"];
|
|
73128
73326
|
var BATTERY = ["device-battery-low", "device-battery-normal"];
|
|
@@ -73132,6 +73330,11 @@ var TANK = [
|
|
|
73132
73330
|
"device-tank-full",
|
|
73133
73331
|
"device-tank-normal"
|
|
73134
73332
|
];
|
|
73333
|
+
var ALERT_EPISODE = [
|
|
73334
|
+
"alert-critical",
|
|
73335
|
+
"alert-error",
|
|
73336
|
+
"alert-critical-resolved"
|
|
73337
|
+
];
|
|
73135
73338
|
var UPDATES = [
|
|
73136
73339
|
"addon-update-available",
|
|
73137
73340
|
"server-update-available",
|
|
@@ -73324,14 +73527,14 @@ var STATE_SUMMARY_VARS = [
|
|
|
73324
73527
|
([...RULE_TEXT], [...CONSUMABLE]),
|
|
73325
73528
|
([...RULE_TEXT], [...TANK]),
|
|
73326
73529
|
[...RULE_TEXT],
|
|
73327
|
-
([...RULE_TEXT], [...UPDATES]),
|
|
73328
|
-
([...RULE_TEXT], [...UPDATES]),
|
|
73329
|
-
[...RULE_TEXT],
|
|
73530
|
+
([...RULE_TEXT], [...UPDATES, ...ALERT_EPISODE]),
|
|
73531
|
+
([...RULE_TEXT], [...UPDATES, ...ALERT_EPISODE]),
|
|
73330
73532
|
[...RULE_TEXT],
|
|
73331
73533
|
[...RULE_TEXT],
|
|
73332
73534
|
[...RULE_TEXT],
|
|
73333
73535
|
[...RULE_TEXT],
|
|
73334
73536
|
[...RULE_TEXT],
|
|
73537
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
73335
73538
|
[...RULE_TEXT],
|
|
73336
73539
|
[...RULE_TEXT],
|
|
73337
73540
|
[...RULE_TEXT],
|
|
@@ -73349,7 +73552,11 @@ var STATE_SUMMARY_VARS = [
|
|
|
73349
73552
|
[...RULE_TEXT],
|
|
73350
73553
|
[...RULE_TEXT],
|
|
73351
73554
|
[...RULE_TEXT],
|
|
73352
|
-
[...RULE_TEXT],
|
|
73555
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
73556
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
73557
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
73558
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
73559
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
73353
73560
|
[...RULE_TEXT],
|
|
73354
73561
|
[...RULE_TEXT],
|
|
73355
73562
|
[...RULE_TEXT],
|
package/dist/smtp.addon.mjs
CHANGED
|
@@ -34,7 +34,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
|
|
|
34
34
|
var __toCommonJS = (mod) => __hasOwnProp.call(mod, "module.exports") ? mod["module.exports"] : __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
|
35
35
|
var __require = /* @__PURE__ */ createRequire(import.meta.url);
|
|
36
36
|
//#endregion
|
|
37
|
-
//#region ../types/dist/event-category-
|
|
37
|
+
//#region ../types/dist/event-category-DOl51-Ij.mjs
|
|
38
38
|
var EventCategory = /* @__PURE__ */ function(EventCategory) {
|
|
39
39
|
EventCategory["SystemBoot"] = "system.boot";
|
|
40
40
|
EventCategory["SystemAddonsReady"] = "system.addons-ready";
|
|
@@ -113,9 +113,18 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
|
|
|
113
113
|
/**
|
|
114
114
|
* The node's one-shot runner boot check (D877): planned runners against the
|
|
115
115
|
* process service, `degraded` when any is failed, refused or missing. The
|
|
116
|
-
* alert centre turns it into one
|
|
116
|
+
* alert centre turns it into one critical alert.
|
|
117
117
|
*/
|
|
118
118
|
EventCategory["SystemRunnerCheck"] = "system.runner-check";
|
|
119
|
+
/**
|
|
120
|
+
* An alert EPISODE opened or closed, emitted by the alert centre for alerts
|
|
121
|
+
* of severity `critical` or `error` (`AlertEpisodePayload`). The alert
|
|
122
|
+
* centre sends no notification of its own: Notification Center turns this
|
|
123
|
+
* into the `alert-critical` / `alert-error` / `alert-critical-resolved`
|
|
124
|
+
* system-event kinds, and reconciles from the alerts store because a bus
|
|
125
|
+
* event may be dropped (D8, D11).
|
|
126
|
+
*/
|
|
127
|
+
EventCategory["AlertEpisode"] = "alert.episode";
|
|
119
128
|
EventCategory["AddonError"] = "addon.error";
|
|
120
129
|
EventCategory["AddonPageReady"] = "addon.page-ready";
|
|
121
130
|
EventCategory["AddonWidgetReady"] = "addon.widget-ready";
|
|
@@ -5440,7 +5449,7 @@ var ZodIssueCode = {
|
|
|
5440
5449
|
var ZodFirstPartyTypeKind;
|
|
5441
5450
|
ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
|
|
5442
5451
|
//#endregion
|
|
5443
|
-
//#region ../types/dist/sleep-
|
|
5452
|
+
//#region ../types/dist/sleep-BxjU_fJM.mjs
|
|
5444
5453
|
/**
|
|
5445
5454
|
* The audio chunk plane's byte format, and the ONE expansion from a coded
|
|
5446
5455
|
* window to float samples (D455).
|
|
@@ -13122,7 +13131,14 @@ var AlertSeveritySchema = _enum([
|
|
|
13122
13131
|
]);
|
|
13123
13132
|
var AlertActionSchema = object({
|
|
13124
13133
|
label: string(),
|
|
13125
|
-
href: string().optional()
|
|
13134
|
+
href: string().optional(),
|
|
13135
|
+
/**
|
|
13136
|
+
* How `href` is followed. Absent / `app`: an admin-ui route (client-side).
|
|
13137
|
+
* `server`: a route the HUB serves (an addon HTTP route such as an OAuth
|
|
13138
|
+
* start) — the browser must leave the SPA with a full navigation, because
|
|
13139
|
+
* the SPA has no such route and would bounce to the home page.
|
|
13140
|
+
*/
|
|
13141
|
+
navigation: _enum(["app", "server"]).optional()
|
|
13126
13142
|
});
|
|
13127
13143
|
var AlertStatusSchema = _enum([
|
|
13128
13144
|
"active",
|
|
@@ -41498,6 +41514,9 @@ var NcSystemEventKindSchema = _enum([
|
|
|
41498
41514
|
"server-updated",
|
|
41499
41515
|
"export-completed",
|
|
41500
41516
|
"backup-completed",
|
|
41517
|
+
"alert-critical",
|
|
41518
|
+
"alert-error",
|
|
41519
|
+
"alert-critical-resolved",
|
|
41501
41520
|
"camera-online",
|
|
41502
41521
|
"camera-offline",
|
|
41503
41522
|
"camera-disabled",
|
|
@@ -50543,7 +50562,10 @@ method(StorageMigrationInputSchema, StorageMigrationPlanSchema, { auth: "admin"
|
|
|
50543
50562
|
}), method(object({ jobId: string().optional() }), StorageMigrationJobSchema.nullable(), { auth: "admin" }), method(object({ jobId: string() }), object({ cancelled: boolean() }), {
|
|
50544
50563
|
kind: "mutation",
|
|
50545
50564
|
auth: "admin"
|
|
50546
|
-
}), method(object({}), array(StorageMigrationMoverSchema).readonly(), { auth: "admin" }), method(object({
|
|
50565
|
+
}), method(object({}), array(StorageMigrationMoverSchema).readonly(), { auth: "admin" }), method(object({ locationIds: array(string()).readonly() }), object({
|
|
50566
|
+
clear: boolean(),
|
|
50567
|
+
repointLocationId: string().optional()
|
|
50568
|
+
}), { auth: "admin" }), method(object({}), array(StorageMigrationResidueSchema).readonly(), { auth: "admin" }), method(StorageMigrationDrainInputSchema, object({ jobId: string() }), {
|
|
50547
50569
|
kind: "mutation",
|
|
50548
50570
|
auth: "admin"
|
|
50549
50571
|
}), method(StorageCleanupInputSchema, object({ jobId: string() }), {
|
|
@@ -53978,6 +54000,11 @@ object({
|
|
|
53978
54000
|
*
|
|
53979
54001
|
* `kind: 'poll'` — cloud REST APIs typically have no push channel; the
|
|
53980
54002
|
* provider refreshes the slice on an interval and eagerly after commands.
|
|
54003
|
+
*
|
|
54004
|
+
* UNKNOWN IS NOT OFF. Every field the appliance reports separately is
|
|
54005
|
+
* nullable: `null` means "not known right now" (the appliance has not said,
|
|
54006
|
+
* the link is down, or the description does not carry it) and is never
|
|
54007
|
+
* rendered or exported as `false` / `0`. `availability` says why.
|
|
53981
54008
|
*/
|
|
53982
54009
|
var DishwasherStateSchema = _enum([
|
|
53983
54010
|
"idle",
|
|
@@ -53987,112 +54014,227 @@ var DishwasherStateSchema = _enum([
|
|
|
53987
54014
|
"error",
|
|
53988
54015
|
"unavailable"
|
|
53989
54016
|
]);
|
|
54017
|
+
/**
|
|
54018
|
+
* The appliance's own operation state, uncollapsed. `state` above is the coarse
|
|
54019
|
+
* view for compact surfaces; this is what the appliance said.
|
|
54020
|
+
*/
|
|
54021
|
+
var DishwasherOperationStateSchema = _enum([
|
|
54022
|
+
"Inactive",
|
|
54023
|
+
"Ready",
|
|
54024
|
+
"DelayedStart",
|
|
54025
|
+
"Run",
|
|
54026
|
+
"Pause",
|
|
54027
|
+
"ActionRequired",
|
|
54028
|
+
"Finished",
|
|
54029
|
+
"Error",
|
|
54030
|
+
"Aborting"
|
|
54031
|
+
]);
|
|
54032
|
+
/**
|
|
54033
|
+
* Why fields may be `null`:
|
|
54034
|
+
* - `available` — the link is up and the description is loaded;
|
|
54035
|
+
* - `offline` — the local link is down (values are unknown, not last-known);
|
|
54036
|
+
* - `description-missing` — the link is up but the appliance's description could not
|
|
54037
|
+
* be loaded, so its values cannot be decoded.
|
|
54038
|
+
*/
|
|
54039
|
+
var DishwasherAvailabilitySchema = _enum([
|
|
54040
|
+
"available",
|
|
54041
|
+
"offline",
|
|
54042
|
+
"description-missing"
|
|
54043
|
+
]);
|
|
53990
54044
|
var DishwasherConsumableLevelSchema = _enum([
|
|
53991
54045
|
"ok",
|
|
53992
54046
|
"low",
|
|
53993
54047
|
"empty"
|
|
53994
54048
|
]);
|
|
53995
54049
|
object({
|
|
54050
|
+
availability: DishwasherAvailabilitySchema,
|
|
54051
|
+
/** Coarse state for compact surfaces; `unavailable` whenever the appliance state is not known. */
|
|
53996
54052
|
state: DishwasherStateSchema,
|
|
53997
|
-
/**
|
|
54053
|
+
/** The appliance's operation state as reported; null when not known. */
|
|
54054
|
+
operationState: DishwasherOperationStateSchema.nullable(),
|
|
54055
|
+
/** Feature key of the ACTIVE (running) program, or null when none runs / not known. */
|
|
53998
54056
|
program: string().nullable(),
|
|
53999
|
-
/**
|
|
54057
|
+
/** Feature key of the SELECTED program (what Start would run), or null when none / not known. */
|
|
54058
|
+
selectedProgram: string().nullable(),
|
|
54059
|
+
/** Feature keys of the programs the appliance currently offers — drives the UI selector. */
|
|
54000
54060
|
availablePrograms: array(string()),
|
|
54001
|
-
/**
|
|
54002
|
-
|
|
54061
|
+
/** Seconds remaining on the active cycle, or null when not running / not known. */
|
|
54062
|
+
remainingSeconds: number().int().nonnegative().nullable(),
|
|
54063
|
+
/** Seconds the delayed start is set to (time until the cycle starts), or null. */
|
|
54064
|
+
delayedStartSeconds: number().int().nonnegative().nullable(),
|
|
54003
54065
|
/** Cycle completion 0..100, or null when not applicable. */
|
|
54004
54066
|
progressPercent: number().min(0).max(100).nullable(),
|
|
54005
|
-
/** True when the door is reported open. */
|
|
54006
|
-
doorOpen: boolean(),
|
|
54007
|
-
/** True when
|
|
54008
|
-
|
|
54009
|
-
/**
|
|
54010
|
-
|
|
54067
|
+
/** True when the door is reported open; null when the door state is not known. */
|
|
54068
|
+
doorOpen: boolean().nullable(),
|
|
54069
|
+
/** True when the door is latched (locked) during a cycle; null when not reported. */
|
|
54070
|
+
doorLocked: boolean().nullable(),
|
|
54071
|
+
/** True when remote start is allowed (door closed, power on, etc.); null when not known. */
|
|
54072
|
+
remoteStartAllowed: boolean().nullable(),
|
|
54073
|
+
/** True when the appliance accepts remote control now; null when not known. */
|
|
54074
|
+
remoteControlActive: boolean().nullable(),
|
|
54075
|
+
/** True while somebody operates the appliance at its panel; null when not reported. */
|
|
54076
|
+
localControlActive: boolean().nullable(),
|
|
54077
|
+
/** Main power / switched-on state; null when not known. */
|
|
54078
|
+
powerOn: boolean().nullable(),
|
|
54079
|
+
/** The raw power state (`On`, `Off`, `Standby`, …); null when not known. */
|
|
54080
|
+
powerState: string().nullable(),
|
|
54011
54081
|
saltLevel: DishwasherConsumableLevelSchema.nullable(),
|
|
54012
54082
|
rinseAidLevel: DishwasherConsumableLevelSchema.nullable(),
|
|
54013
|
-
|
|
54014
|
-
|
|
54083
|
+
/** Option states: null when the appliance does not expose the option or has not said. */
|
|
54084
|
+
halfLoad: boolean().nullable(),
|
|
54085
|
+
hygienePlus: boolean().nullable(),
|
|
54015
54086
|
/** Extra dry option when the appliance exposes it. */
|
|
54016
|
-
extraDry: boolean(),
|
|
54087
|
+
extraDry: boolean().nullable(),
|
|
54017
54088
|
/** Intensive zone (lower basket) when the appliance exposes it. */
|
|
54018
|
-
intensiveZone: boolean(),
|
|
54089
|
+
intensiveZone: boolean().nullable(),
|
|
54019
54090
|
/** VarioSpeed / VarioSpeed+ when the appliance exposes it. */
|
|
54020
|
-
varioSpeedPlus: boolean(),
|
|
54021
|
-
/** Child lock (controls disabled on the appliance). */
|
|
54022
|
-
childLock: boolean(),
|
|
54091
|
+
varioSpeedPlus: boolean().nullable(),
|
|
54092
|
+
/** Child lock (controls disabled on the appliance); null when not known. */
|
|
54093
|
+
childLock: boolean().nullable(),
|
|
54094
|
+
/** Feature keys of the events currently raised (salt low, rinse aid low, program finished, …). */
|
|
54095
|
+
activeEvents: array(string()),
|
|
54096
|
+
/** Numeric error code when the appliance reports one; null otherwise. */
|
|
54023
54097
|
errorCode: number().nullable(),
|
|
54098
|
+
/** Name of the raised alert-level event while the appliance is in error; null otherwise. */
|
|
54024
54099
|
errorLabel: string().nullable(),
|
|
54100
|
+
/** Ms epoch of the last value received from the appliance; 0 = never. */
|
|
54025
54101
|
lastFetchedAt: number()
|
|
54026
54102
|
});
|
|
54027
|
-
|
|
54103
|
+
var DeviceIdSchema = number().int().nonnegative();
|
|
54104
|
+
/** A value a program option or setting can take. */
|
|
54105
|
+
var DishwasherValueSchema = union([
|
|
54106
|
+
boolean(),
|
|
54107
|
+
string(),
|
|
54108
|
+
number()
|
|
54109
|
+
]);
|
|
54110
|
+
var DishwasherAccessSchema = _enum([
|
|
54111
|
+
"none",
|
|
54112
|
+
"read",
|
|
54113
|
+
"readWrite",
|
|
54114
|
+
"writeOnly",
|
|
54115
|
+
"readStatic"
|
|
54116
|
+
]);
|
|
54117
|
+
/**
|
|
54118
|
+
* One option or setting the appliance declares, with the constraints its description
|
|
54119
|
+
* gives. A `readWrite` descriptor that is `available` is what `setOption` accepts.
|
|
54120
|
+
*/
|
|
54121
|
+
var DishwasherOptionDescriptorSchema = object({
|
|
54122
|
+
/** Feature key (`Dishcare.Dishwasher.Option.ExtraDry`). */
|
|
54123
|
+
key: string(),
|
|
54124
|
+
/** Last segment of the key, for display. */
|
|
54125
|
+
name: string(),
|
|
54126
|
+
type: _enum([
|
|
54127
|
+
"boolean",
|
|
54128
|
+
"number",
|
|
54129
|
+
"enum",
|
|
54130
|
+
"string"
|
|
54131
|
+
]),
|
|
54132
|
+
access: DishwasherAccessSchema,
|
|
54133
|
+
/** The appliance reports this entity as currently available. */
|
|
54134
|
+
available: boolean(),
|
|
54135
|
+
/** Unit the description declares for a number; null when it declares none. */
|
|
54136
|
+
unit: string().nullable(),
|
|
54137
|
+
min: number().nullable(),
|
|
54138
|
+
max: number().nullable(),
|
|
54139
|
+
step: number().nullable(),
|
|
54140
|
+
/** Allowed members of an enum; null for other types. */
|
|
54141
|
+
enumValues: array(string()).nullable(),
|
|
54142
|
+
defaultValue: DishwasherValueSchema.nullable()
|
|
54143
|
+
});
|
|
54144
|
+
var DishwasherProgramSchema = object({
|
|
54145
|
+
/** Feature key (`Dishcare.Dishwasher.Program.Eco50`) — what `setProgram` / `start` take. */
|
|
54146
|
+
key: string(),
|
|
54147
|
+
name: string(),
|
|
54148
|
+
/** The appliance currently offers this program. */
|
|
54149
|
+
available: boolean(),
|
|
54150
|
+
/** The options this program lists, with the program-level access / availability / default. */
|
|
54151
|
+
options: array(DishwasherOptionDescriptorSchema)
|
|
54152
|
+
});
|
|
54153
|
+
var DishwasherOptionsSchema = object({
|
|
54154
|
+
availability: DishwasherAvailabilitySchema,
|
|
54155
|
+
/** What the appliance can be told to do, from the commands its description declares. */
|
|
54156
|
+
supportsStart: boolean(),
|
|
54157
|
+
supportsPause: boolean(),
|
|
54158
|
+
supportsResume: boolean(),
|
|
54159
|
+
supportsStop: boolean(),
|
|
54160
|
+
supportsPower: boolean(),
|
|
54161
|
+
/** Every program the description lists, with its options. */
|
|
54162
|
+
programs: array(DishwasherProgramSchema),
|
|
54163
|
+
/** Every option and setting entity the description lists (programs reference these by key). */
|
|
54164
|
+
options: array(DishwasherOptionDescriptorSchema)
|
|
54165
|
+
});
|
|
54166
|
+
DeviceType.Dishwasher, method(object({
|
|
54167
|
+
deviceId: DeviceIdSchema,
|
|
54168
|
+
program: string().min(1).optional(),
|
|
54169
|
+
options: record(string(), DishwasherValueSchema).optional()
|
|
54170
|
+
}), _void(), {
|
|
54028
54171
|
kind: "mutation",
|
|
54029
54172
|
auth: "protected"
|
|
54030
|
-
}), method(object({ deviceId:
|
|
54173
|
+
}), method(object({ deviceId: DeviceIdSchema }), _void(), {
|
|
54031
54174
|
kind: "mutation",
|
|
54032
54175
|
auth: "protected"
|
|
54033
|
-
}), method(object({ deviceId:
|
|
54176
|
+
}), method(object({ deviceId: DeviceIdSchema }), _void(), {
|
|
54177
|
+
kind: "mutation",
|
|
54178
|
+
auth: "protected"
|
|
54179
|
+
}), method(object({ deviceId: DeviceIdSchema }), _void(), {
|
|
54034
54180
|
kind: "mutation",
|
|
54035
54181
|
auth: "protected"
|
|
54036
54182
|
}), method(object({
|
|
54037
|
-
deviceId:
|
|
54183
|
+
deviceId: DeviceIdSchema,
|
|
54038
54184
|
program: string().min(1)
|
|
54039
54185
|
}), _void(), {
|
|
54040
54186
|
kind: "mutation",
|
|
54041
54187
|
auth: "protected"
|
|
54042
54188
|
}), method(object({
|
|
54043
|
-
deviceId:
|
|
54189
|
+
deviceId: DeviceIdSchema,
|
|
54044
54190
|
on: boolean()
|
|
54045
54191
|
}), _void(), {
|
|
54046
54192
|
kind: "mutation",
|
|
54047
54193
|
auth: "protected"
|
|
54048
54194
|
}), method(object({
|
|
54049
|
-
deviceId:
|
|
54195
|
+
deviceId: DeviceIdSchema,
|
|
54050
54196
|
on: boolean()
|
|
54051
54197
|
}), _void(), {
|
|
54052
54198
|
kind: "mutation",
|
|
54053
54199
|
auth: "protected"
|
|
54054
54200
|
}), method(object({
|
|
54055
|
-
deviceId:
|
|
54201
|
+
deviceId: DeviceIdSchema,
|
|
54056
54202
|
on: boolean()
|
|
54057
54203
|
}), _void(), {
|
|
54058
54204
|
kind: "mutation",
|
|
54059
54205
|
auth: "protected"
|
|
54060
54206
|
}), method(object({
|
|
54061
|
-
deviceId:
|
|
54207
|
+
deviceId: DeviceIdSchema,
|
|
54062
54208
|
on: boolean()
|
|
54063
54209
|
}), _void(), {
|
|
54064
54210
|
kind: "mutation",
|
|
54065
54211
|
auth: "protected"
|
|
54066
54212
|
}), method(object({
|
|
54067
|
-
deviceId:
|
|
54213
|
+
deviceId: DeviceIdSchema,
|
|
54068
54214
|
on: boolean()
|
|
54069
54215
|
}), _void(), {
|
|
54070
54216
|
kind: "mutation",
|
|
54071
54217
|
auth: "protected"
|
|
54072
54218
|
}), method(object({
|
|
54073
|
-
deviceId:
|
|
54219
|
+
deviceId: DeviceIdSchema,
|
|
54074
54220
|
on: boolean()
|
|
54075
54221
|
}), _void(), {
|
|
54076
54222
|
kind: "mutation",
|
|
54077
54223
|
auth: "protected"
|
|
54078
54224
|
}), method(object({
|
|
54079
|
-
deviceId:
|
|
54225
|
+
deviceId: DeviceIdSchema,
|
|
54080
54226
|
on: boolean()
|
|
54081
54227
|
}), _void(), {
|
|
54082
54228
|
kind: "mutation",
|
|
54083
54229
|
auth: "protected"
|
|
54084
54230
|
}), method(object({
|
|
54085
|
-
deviceId:
|
|
54231
|
+
deviceId: DeviceIdSchema,
|
|
54086
54232
|
key: string().min(1),
|
|
54087
|
-
value:
|
|
54088
|
-
boolean(),
|
|
54089
|
-
string(),
|
|
54090
|
-
number()
|
|
54091
|
-
])
|
|
54233
|
+
value: DishwasherValueSchema
|
|
54092
54234
|
}), _void(), {
|
|
54093
54235
|
kind: "mutation",
|
|
54094
54236
|
auth: "protected"
|
|
54095
|
-
});
|
|
54237
|
+
}), method(object({ deviceId: DeviceIdSchema }), DishwasherOptionsSchema, { auth: "protected" });
|
|
54096
54238
|
object({
|
|
54097
54239
|
/** Ms epoch of the last press. null = never observed since this provider started. */
|
|
54098
54240
|
lastPressedAt: number().nullable(),
|
|
@@ -64152,6 +64294,12 @@ Object.freeze({
|
|
|
64152
64294
|
addonId: null,
|
|
64153
64295
|
access: "view"
|
|
64154
64296
|
},
|
|
64297
|
+
"dishwasher.getOptions": {
|
|
64298
|
+
capName: "dishwasher",
|
|
64299
|
+
capScope: "device",
|
|
64300
|
+
addonId: null,
|
|
64301
|
+
access: "view"
|
|
64302
|
+
},
|
|
64155
64303
|
"dishwasher.getStatus": {
|
|
64156
64304
|
capName: "dishwasher",
|
|
64157
64305
|
capScope: "device",
|
|
@@ -64164,6 +64312,12 @@ Object.freeze({
|
|
|
64164
64312
|
addonId: null,
|
|
64165
64313
|
access: "create"
|
|
64166
64314
|
},
|
|
64315
|
+
"dishwasher.resume": {
|
|
64316
|
+
capName: "dishwasher",
|
|
64317
|
+
capScope: "device",
|
|
64318
|
+
addonId: null,
|
|
64319
|
+
access: "create"
|
|
64320
|
+
},
|
|
64167
64321
|
"dishwasher.setChildLock": {
|
|
64168
64322
|
capName: "dishwasher",
|
|
64169
64323
|
capScope: "device",
|
|
@@ -68664,6 +68818,12 @@ Object.freeze({
|
|
|
68664
68818
|
addonId: null,
|
|
68665
68819
|
access: "view"
|
|
68666
68820
|
},
|
|
68821
|
+
"storageMigration.moverClearance": {
|
|
68822
|
+
capName: "storage-migration",
|
|
68823
|
+
capScope: "system",
|
|
68824
|
+
addonId: null,
|
|
68825
|
+
access: "view"
|
|
68826
|
+
},
|
|
68667
68827
|
"storageMigration.movers": {
|
|
68668
68828
|
capName: "storage-migration",
|
|
68669
68829
|
capScope: "system",
|
|
@@ -70857,6 +71017,11 @@ Object.freeze({
|
|
|
70857
71017
|
form: "single",
|
|
70858
71018
|
optional: false
|
|
70859
71019
|
}],
|
|
71020
|
+
"dishwasher.getOptions": [{
|
|
71021
|
+
name: "deviceId",
|
|
71022
|
+
form: "single",
|
|
71023
|
+
optional: false
|
|
71024
|
+
}],
|
|
70860
71025
|
"dishwasher.getStatus": [{
|
|
70861
71026
|
name: "deviceId",
|
|
70862
71027
|
form: "single",
|
|
@@ -70867,6 +71032,11 @@ Object.freeze({
|
|
|
70867
71032
|
form: "single",
|
|
70868
71033
|
optional: false
|
|
70869
71034
|
}],
|
|
71035
|
+
"dishwasher.resume": [{
|
|
71036
|
+
name: "deviceId",
|
|
71037
|
+
form: "single",
|
|
71038
|
+
optional: false
|
|
71039
|
+
}],
|
|
70870
71040
|
"dishwasher.setChildLock": [{
|
|
70871
71041
|
name: "deviceId",
|
|
70872
71042
|
form: "single",
|
|
@@ -72953,6 +73123,9 @@ new Map(Object.entries({
|
|
|
72953
73123
|
"wrapper-update-available": "system",
|
|
72954
73124
|
"backup-completed": "system",
|
|
72955
73125
|
"export-completed": "system",
|
|
73126
|
+
"alert-critical": "system",
|
|
73127
|
+
"alert-error": "system",
|
|
73128
|
+
"alert-critical-resolved": "system",
|
|
72956
73129
|
"storage-location-low": "system",
|
|
72957
73130
|
"storage-location-critical": "system",
|
|
72958
73131
|
"storage-location-ok": "system",
|
|
@@ -73077,6 +73250,16 @@ var NC_SYSTEM_EVENT_KIND_GROUP_SPECS = [
|
|
|
73077
73250
|
"storage-location-ok"
|
|
73078
73251
|
]
|
|
73079
73252
|
},
|
|
73253
|
+
{
|
|
73254
|
+
id: "alerts",
|
|
73255
|
+
family: "system",
|
|
73256
|
+
label: "Alerts",
|
|
73257
|
+
kinds: [
|
|
73258
|
+
"alert-critical",
|
|
73259
|
+
"alert-error",
|
|
73260
|
+
"alert-critical-resolved"
|
|
73261
|
+
]
|
|
73262
|
+
},
|
|
73080
73263
|
{
|
|
73081
73264
|
id: "alarm",
|
|
73082
73265
|
family: "alarm",
|
|
@@ -73121,6 +73304,21 @@ var NC_SENSOR_RAISED_FIELD_BY_KIND = Object.freeze(Object.fromEntries(Object.ent
|
|
|
73121
73304
|
return [[descriptor.kind, field]];
|
|
73122
73305
|
})));
|
|
73123
73306
|
Object.freeze(Object.keys(NC_SENSOR_RAISED_FIELD_BY_KIND));
|
|
73307
|
+
object({
|
|
73308
|
+
phase: _enum(["raised", "resolved"]),
|
|
73309
|
+
episodeId: string().min(1),
|
|
73310
|
+
alertId: string().min(1),
|
|
73311
|
+
severity: AlertSeveritySchema,
|
|
73312
|
+
category: string(),
|
|
73313
|
+
title: string(),
|
|
73314
|
+
message: string(),
|
|
73315
|
+
sourceType: string().optional(),
|
|
73316
|
+
sourceId: string().optional(),
|
|
73317
|
+
nodeId: string().optional(),
|
|
73318
|
+
/** The alert's own action link (where the operator acts on it), when it has one. */
|
|
73319
|
+
actionUrl: string().optional(),
|
|
73320
|
+
at: number()
|
|
73321
|
+
});
|
|
73124
73322
|
var RULE_BODY_ONLY = ["body"];
|
|
73125
73323
|
var RULE_TEXT = ["title", "body"];
|
|
73126
73324
|
var BATTERY = ["device-battery-low", "device-battery-normal"];
|
|
@@ -73130,6 +73328,11 @@ var TANK = [
|
|
|
73130
73328
|
"device-tank-full",
|
|
73131
73329
|
"device-tank-normal"
|
|
73132
73330
|
];
|
|
73331
|
+
var ALERT_EPISODE = [
|
|
73332
|
+
"alert-critical",
|
|
73333
|
+
"alert-error",
|
|
73334
|
+
"alert-critical-resolved"
|
|
73335
|
+
];
|
|
73133
73336
|
var UPDATES = [
|
|
73134
73337
|
"addon-update-available",
|
|
73135
73338
|
"server-update-available",
|
|
@@ -73322,14 +73525,14 @@ var STATE_SUMMARY_VARS = [
|
|
|
73322
73525
|
([...RULE_TEXT], [...CONSUMABLE]),
|
|
73323
73526
|
([...RULE_TEXT], [...TANK]),
|
|
73324
73527
|
[...RULE_TEXT],
|
|
73325
|
-
([...RULE_TEXT], [...UPDATES]),
|
|
73326
|
-
([...RULE_TEXT], [...UPDATES]),
|
|
73327
|
-
[...RULE_TEXT],
|
|
73528
|
+
([...RULE_TEXT], [...UPDATES, ...ALERT_EPISODE]),
|
|
73529
|
+
([...RULE_TEXT], [...UPDATES, ...ALERT_EPISODE]),
|
|
73328
73530
|
[...RULE_TEXT],
|
|
73329
73531
|
[...RULE_TEXT],
|
|
73330
73532
|
[...RULE_TEXT],
|
|
73331
73533
|
[...RULE_TEXT],
|
|
73332
73534
|
[...RULE_TEXT],
|
|
73535
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
73333
73536
|
[...RULE_TEXT],
|
|
73334
73537
|
[...RULE_TEXT],
|
|
73335
73538
|
[...RULE_TEXT],
|
|
@@ -73347,7 +73550,11 @@ var STATE_SUMMARY_VARS = [
|
|
|
73347
73550
|
[...RULE_TEXT],
|
|
73348
73551
|
[...RULE_TEXT],
|
|
73349
73552
|
[...RULE_TEXT],
|
|
73350
|
-
[...RULE_TEXT],
|
|
73553
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
73554
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
73555
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
73556
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
73557
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
73351
73558
|
[...RULE_TEXT],
|
|
73352
73559
|
[...RULE_TEXT],
|
|
73353
73560
|
[...RULE_TEXT],
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@camstack/addon-smtp-nodemailer",
|
|
3
|
-
"version": "1.2.
|
|
3
|
+
"version": "1.2.124",
|
|
4
4
|
"description": "SMTP email provider addon for CamStack — wraps `nodemailer` and registers a `smtp-provider` cap collection entry. Used by notifier addons.",
|
|
5
5
|
"keywords": [
|
|
6
6
|
"camstack",
|