@camstack/addon-export-google 0.1.94 → 0.1.96
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 +480 -240
- package/dist/export-google.addon.mjs +480 -240
- 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).
|
|
@@ -7865,6 +7874,12 @@ function normalizeAddonInitResult(result) {
|
|
|
7865
7874
|
if (Array.isArray(result)) return { providers: result };
|
|
7866
7875
|
return result;
|
|
7867
7876
|
}
|
|
7877
|
+
/**
|
|
7878
|
+
* The share-view scope kinds a `csv_*` share token can carry. The hub mints
|
|
7879
|
+
* and validates them (`share-token.service.ts` builds its enum from this
|
|
7880
|
+
* list); a data plane names the kinds it ACCEPTS in `share`.
|
|
7881
|
+
*/
|
|
7882
|
+
var SHARE_VIEW_KINDS = ["grid-view", "events-view"];
|
|
7868
7883
|
/** The wire shape of {@link PeerBytesTicket} — see the type for what it is. */
|
|
7869
7884
|
var PeerBytesTicketSchema = object({
|
|
7870
7885
|
/** `http://127.0.0.1:<port>/<token>`. One `GET` takes it. */
|
|
@@ -12605,6 +12620,229 @@ var ConvertResultSchema = object({
|
|
|
12605
12620
|
function scopesAllowDeviceCap(scopes, access) {
|
|
12606
12621
|
return scopes.some((s) => s.type === "category" && s.target === "device" && s.access.includes(access));
|
|
12607
12622
|
}
|
|
12623
|
+
/**
|
|
12624
|
+
* Zod schemas for persisted record types.
|
|
12625
|
+
*
|
|
12626
|
+
* These schemas serve as the single source of truth for types that are
|
|
12627
|
+
* stored in the settings-store backend and retrieved via tRPC. They
|
|
12628
|
+
* replace the manual TypeScript interfaces with schema-derived types,
|
|
12629
|
+
* enabling runtime validation when reading from the backend.
|
|
12630
|
+
*
|
|
12631
|
+
* Convention: each schema is named `<Type>Schema`, the inferred TS type
|
|
12632
|
+
* keeps the original name for backward compatibility.
|
|
12633
|
+
*/
|
|
12634
|
+
/**
|
|
12635
|
+
* Auth model (v2 — 2026-05-12 caps-only):
|
|
12636
|
+
*
|
|
12637
|
+
* Two principals:
|
|
12638
|
+
* - `isAdmin: true` — full bypass. Admin scope set is ignored.
|
|
12639
|
+
* - `isAdmin: false` — every call gated by `scopes` (see TokenScope).
|
|
12640
|
+
*
|
|
12641
|
+
* No role enum. There used to be `viewer / agent / scoped` and earlier
|
|
12642
|
+
* `super_admin` — collapsed onto the single boolean because every
|
|
12643
|
+
* non-admin caller is governed by the same scope-check rules; the
|
|
12644
|
+
* distinction was only ever used to route role-specific procedures
|
|
12645
|
+
* which we no longer have. CLI / webhook integrations are `cst_*` tokens
|
|
12646
|
+
* with `isAdmin: false` + an explicit scope list.
|
|
12647
|
+
*/
|
|
12648
|
+
/** Per-method access flavour. Materialised on every cap method via codegen. */
|
|
12649
|
+
var MethodAccessSchema = _enum([
|
|
12650
|
+
"view",
|
|
12651
|
+
"create",
|
|
12652
|
+
"delete"
|
|
12653
|
+
]);
|
|
12654
|
+
/**
|
|
12655
|
+
* A single scope grant. Three forms — checked in matcher with OR
|
|
12656
|
+
* semantics; the first match decides whether the call passes:
|
|
12657
|
+
*
|
|
12658
|
+
* - `category` — broadest. `target: 'device' | 'system'` selects every
|
|
12659
|
+
* cap with the matching `scope` declaration. New caps inherit grants
|
|
12660
|
+
* automatically — adding a device cap to the codebase makes it
|
|
12661
|
+
* reachable to every user with `category:device [...]` without a
|
|
12662
|
+
* re-grant. Use this for "family viewer" / "operator" tiers.
|
|
12663
|
+
*
|
|
12664
|
+
* - `addon` — every cap that ships inside a given addon id. Niche;
|
|
12665
|
+
* useful when an integration needs to interact with one specific
|
|
12666
|
+
* addon's surface regardless of how many caps it exports.
|
|
12667
|
+
*
|
|
12668
|
+
* - `capability` — the most precise form. Single cap name. Use for
|
|
12669
|
+
* integration tokens where you want to grant `addons.installPackage`
|
|
12670
|
+
* and nothing else.
|
|
12671
|
+
*
|
|
12672
|
+
* `access` is REQUIRED with min 1 element. `admin` bypass is the
|
|
12673
|
+
* "give me everything" escape; there is no wildcard scope.
|
|
12674
|
+
*/
|
|
12675
|
+
var AllowedProviderSchema = union([literal("*"), array(string())]);
|
|
12676
|
+
var AllowedDevicesSchema = record(string(), union([literal("*"), array(string())]));
|
|
12677
|
+
var CapScopeSchema = _enum(["device", "system"]);
|
|
12678
|
+
/**
|
|
12679
|
+
* DeviceSelector (scope model v3 — 2026-08-12).
|
|
12680
|
+
*
|
|
12681
|
+
* A `device` grant no longer carries a frozen list of deviceIds. It carries
|
|
12682
|
+
* a SELECTOR the matcher resolves against the live fleet, so the grant can be
|
|
12683
|
+
* DYNAMIC: a `types:['camera']` selector automatically covers a camera added
|
|
12684
|
+
* AFTER the grant was minted — no re-grant, no re-login.
|
|
12685
|
+
*
|
|
12686
|
+
* - `all` — every device in the deployment. The broad viewer/operator
|
|
12687
|
+
* lever without a `category` grant (a `category` grant also covers device
|
|
12688
|
+
* caps that carry no deviceId; `all` is specifically the device set).
|
|
12689
|
+
* - `ids` — an explicit deviceId list. This is what a v2 `device:[…]`
|
|
12690
|
+
* grant migrates to (see {@link TokenScopeSchema}); STATIC — a new camera
|
|
12691
|
+
* is NOT covered until the grant is edited.
|
|
12692
|
+
* - `types` — every device of a `DeviceType` (e.g. every `camera`).
|
|
12693
|
+
* DYNAMIC. A device that changes type, or a new device of the type,
|
|
12694
|
+
* re-resolves on the next request.
|
|
12695
|
+
* - `locations` — every device whose operator-assigned `location` label is
|
|
12696
|
+
* in the set (e.g. "Garden", "Front door"). DYNAMIC. A device with a
|
|
12697
|
+
* null/unset location matches NO `locations` selector.
|
|
12698
|
+
*/
|
|
12699
|
+
var DeviceSelectorSchema = discriminatedUnion("kind", [
|
|
12700
|
+
object({ kind: literal("all") }),
|
|
12701
|
+
object({
|
|
12702
|
+
kind: literal("ids"),
|
|
12703
|
+
ids: array(number().int()).min(1)
|
|
12704
|
+
}),
|
|
12705
|
+
object({
|
|
12706
|
+
kind: literal("types"),
|
|
12707
|
+
types: array(_enum(DeviceType)).min(1)
|
|
12708
|
+
}),
|
|
12709
|
+
object({
|
|
12710
|
+
kind: literal("locations"),
|
|
12711
|
+
locations: array(string().min(1)).min(1)
|
|
12712
|
+
})
|
|
12713
|
+
]);
|
|
12714
|
+
var DeviceTokenScopeSchema = object({
|
|
12715
|
+
type: literal("device"),
|
|
12716
|
+
/** The device SET this grant covers — resolved against the live fleet. */
|
|
12717
|
+
selector: DeviceSelectorSchema,
|
|
12718
|
+
access: array(MethodAccessSchema).min(1),
|
|
12719
|
+
/**
|
|
12720
|
+
* Whether a grant on a PARENT device transparently covers its accessory
|
|
12721
|
+
* CHILDREN (siren / floodlight / PIR) via the persisted-parentage walk.
|
|
12722
|
+
* Direction is parent → children ONLY.
|
|
12723
|
+
*
|
|
12724
|
+
* Absent → the matcher DERIVES it from the access flavour: `view`
|
|
12725
|
+
* inherits (a camera viewer sees the camera's accessories), `create` /
|
|
12726
|
+
* `delete` do NOT (actuating/removing a child is an explicit act the
|
|
12727
|
+
* operator must grant on the child, not inherit from the parent). Set it
|
|
12728
|
+
* explicitly to override that default per grant.
|
|
12729
|
+
*/
|
|
12730
|
+
includeLinked: boolean().optional()
|
|
12731
|
+
});
|
|
12732
|
+
/**
|
|
12733
|
+
* v2 → v3 lazy migration. A pre-v3 `device` grant carried
|
|
12734
|
+
* `targets: string[]` (stringified deviceIds); it rewrites to the equivalent
|
|
12735
|
+
* `selector: {kind:'ids', ids}`. Applied as a `preprocess` so it runs on
|
|
12736
|
+
* EVERY parse path — stored records AND the JWT-carried scope arrays
|
|
12737
|
+
* normalised at the request boundary ({@link normalizeTokenScopes} in
|
|
12738
|
+
* `device-selector.ts`). Chosen over a one-time DB migration because a
|
|
12739
|
+
* migration cannot reach a JWT already in a client's hands; parse-time
|
|
12740
|
+
* migration covers both without a flag day. No cast — the raw object is read
|
|
12741
|
+
* through `Reflect.get` (its static type is `unknown`).
|
|
12742
|
+
*/
|
|
12743
|
+
function migrateLegacyTokenScope(raw) {
|
|
12744
|
+
if (raw === null || typeof raw !== "object" || Array.isArray(raw)) return raw;
|
|
12745
|
+
if (Reflect.get(raw, "type") !== "device") return raw;
|
|
12746
|
+
if (Reflect.get(raw, "selector") !== void 0) return raw;
|
|
12747
|
+
const targets = Reflect.get(raw, "targets");
|
|
12748
|
+
if (!Array.isArray(targets)) return raw;
|
|
12749
|
+
return {
|
|
12750
|
+
type: "device",
|
|
12751
|
+
selector: {
|
|
12752
|
+
kind: "ids",
|
|
12753
|
+
ids: targets.map((t) => typeof t === "string" ? Number(t) : t).filter((n) => typeof n === "number" && Number.isInteger(n))
|
|
12754
|
+
},
|
|
12755
|
+
access: Reflect.get(raw, "access")
|
|
12756
|
+
};
|
|
12757
|
+
}
|
|
12758
|
+
var TokenScopeSchema = preprocess(migrateLegacyTokenScope, discriminatedUnion("type", [
|
|
12759
|
+
object({
|
|
12760
|
+
type: literal("category"),
|
|
12761
|
+
target: CapScopeSchema,
|
|
12762
|
+
access: array(MethodAccessSchema).min(1)
|
|
12763
|
+
}),
|
|
12764
|
+
object({
|
|
12765
|
+
type: literal("capability"),
|
|
12766
|
+
target: string(),
|
|
12767
|
+
access: array(MethodAccessSchema).min(1)
|
|
12768
|
+
}),
|
|
12769
|
+
object({
|
|
12770
|
+
type: literal("addon"),
|
|
12771
|
+
target: string(),
|
|
12772
|
+
access: array(MethodAccessSchema).min(1)
|
|
12773
|
+
}),
|
|
12774
|
+
DeviceTokenScopeSchema
|
|
12775
|
+
]));
|
|
12776
|
+
object({
|
|
12777
|
+
id: string(),
|
|
12778
|
+
username: string(),
|
|
12779
|
+
passwordHash: string(),
|
|
12780
|
+
/**
|
|
12781
|
+
* Admin bypass. When true, the middleware skips the scope-access
|
|
12782
|
+
* check entirely. There is no other axis of privilege; the legacy
|
|
12783
|
+
* role enum collapsed onto this boolean in v2.
|
|
12784
|
+
*/
|
|
12785
|
+
isAdmin: boolean().default(false),
|
|
12786
|
+
allowedProviders: AllowedProviderSchema,
|
|
12787
|
+
allowedDevices: AllowedDevicesSchema,
|
|
12788
|
+
/**
|
|
12789
|
+
* Scopes granted to this user. Admins bypass; their `scopes` is
|
|
12790
|
+
* ignored. Non-admins without scopes are locked out of every
|
|
12791
|
+
* protected call.
|
|
12792
|
+
*/
|
|
12793
|
+
scopes: array(TokenScopeSchema).default([]),
|
|
12794
|
+
createdAt: number(),
|
|
12795
|
+
updatedAt: number()
|
|
12796
|
+
});
|
|
12797
|
+
object({
|
|
12798
|
+
id: string(),
|
|
12799
|
+
label: string(),
|
|
12800
|
+
isAdmin: boolean().default(false),
|
|
12801
|
+
allowedProviders: AllowedProviderSchema,
|
|
12802
|
+
allowedDevices: AllowedDevicesSchema,
|
|
12803
|
+
tokenHash: string(),
|
|
12804
|
+
tokenPrefix: string(),
|
|
12805
|
+
createdAt: number(),
|
|
12806
|
+
lastUsedAt: number().optional()
|
|
12807
|
+
});
|
|
12808
|
+
object({
|
|
12809
|
+
id: string(),
|
|
12810
|
+
userId: string(),
|
|
12811
|
+
name: string(),
|
|
12812
|
+
tokenHash: string(),
|
|
12813
|
+
tokenPrefix: string(),
|
|
12814
|
+
scopes: array(TokenScopeSchema),
|
|
12815
|
+
expiresAt: number().nullish(),
|
|
12816
|
+
lastUsedAt: number().nullish(),
|
|
12817
|
+
createdAt: number()
|
|
12818
|
+
});
|
|
12819
|
+
/** What a share-view grant lets its holder see. */
|
|
12820
|
+
var ShareViewGrantSchema = object({
|
|
12821
|
+
kind: _enum(SHARE_VIEW_KINDS),
|
|
12822
|
+
deviceIds: array(number().int().nonnegative()).min(1).max(64),
|
|
12823
|
+
/** Talk-back, opt-in at mint time; absent means off. */
|
|
12824
|
+
talk: boolean().optional()
|
|
12825
|
+
});
|
|
12826
|
+
var ShareViewScopeSchema = object({
|
|
12827
|
+
type: literal("share-view"),
|
|
12828
|
+
grant: ShareViewGrantSchema
|
|
12829
|
+
});
|
|
12830
|
+
var AddonRoutesScopeSchema = object({
|
|
12831
|
+
type: literal("addon-routes"),
|
|
12832
|
+
access: array(MethodAccessSchema).min(1)
|
|
12833
|
+
});
|
|
12834
|
+
var CredentialScopeSchema = union([
|
|
12835
|
+
literal("*"),
|
|
12836
|
+
ShareViewScopeSchema,
|
|
12837
|
+
AddonRoutesScopeSchema,
|
|
12838
|
+
TokenScopeSchema
|
|
12839
|
+
]);
|
|
12840
|
+
object({
|
|
12841
|
+
kind: literal("credential"),
|
|
12842
|
+
sub: string().min(1),
|
|
12843
|
+
jti: string().min(16),
|
|
12844
|
+
scopes: array(CredentialScopeSchema).min(1)
|
|
12845
|
+
});
|
|
12608
12846
|
_enum(["new-session", "step-up"]);
|
|
12609
12847
|
/** The languages the hub's app landing pages are written in (D858). */
|
|
12610
12848
|
var AppPageLangSchema = _enum(["en", "it"]);
|
|
@@ -13340,7 +13578,14 @@ var AlertSeveritySchema = _enum([
|
|
|
13340
13578
|
]);
|
|
13341
13579
|
var AlertActionSchema = object({
|
|
13342
13580
|
label: string(),
|
|
13343
|
-
href: string().optional()
|
|
13581
|
+
href: string().optional(),
|
|
13582
|
+
/**
|
|
13583
|
+
* How `href` is followed. Absent / `app`: an admin-ui route (client-side).
|
|
13584
|
+
* `server`: a route the HUB serves (an addon HTTP route such as an OAuth
|
|
13585
|
+
* start) — the browser must leave the SPA with a full navigation, because
|
|
13586
|
+
* the SPA has no such route and would bounce to the home page.
|
|
13587
|
+
*/
|
|
13588
|
+
navigation: _enum(["app", "server"]).optional()
|
|
13344
13589
|
});
|
|
13345
13590
|
var AlertStatusSchema = _enum([
|
|
13346
13591
|
"active",
|
|
@@ -41741,6 +41986,9 @@ var NcSystemEventKindSchema = _enum([
|
|
|
41741
41986
|
"server-updated",
|
|
41742
41987
|
"export-completed",
|
|
41743
41988
|
"backup-completed",
|
|
41989
|
+
"alert-critical",
|
|
41990
|
+
"alert-error",
|
|
41991
|
+
"alert-critical-resolved",
|
|
41744
41992
|
"camera-online",
|
|
41745
41993
|
"camera-offline",
|
|
41746
41994
|
"camera-disabled",
|
|
@@ -43776,202 +44024,6 @@ method(object({}), object({ rules: array(NcRuleSchema) }), { auth: "admin" }), m
|
|
|
43776
44024
|
auth: "admin"
|
|
43777
44025
|
}), method(NcAlarmSensorsInputSchema, NcAlarmSensorsSchema, { auth: "admin" });
|
|
43778
44026
|
/**
|
|
43779
|
-
* Zod schemas for persisted record types.
|
|
43780
|
-
*
|
|
43781
|
-
* These schemas serve as the single source of truth for types that are
|
|
43782
|
-
* stored in the settings-store backend and retrieved via tRPC. They
|
|
43783
|
-
* replace the manual TypeScript interfaces with schema-derived types,
|
|
43784
|
-
* enabling runtime validation when reading from the backend.
|
|
43785
|
-
*
|
|
43786
|
-
* Convention: each schema is named `<Type>Schema`, the inferred TS type
|
|
43787
|
-
* keeps the original name for backward compatibility.
|
|
43788
|
-
*/
|
|
43789
|
-
/**
|
|
43790
|
-
* Auth model (v2 — 2026-05-12 caps-only):
|
|
43791
|
-
*
|
|
43792
|
-
* Two principals:
|
|
43793
|
-
* - `isAdmin: true` — full bypass. Admin scope set is ignored.
|
|
43794
|
-
* - `isAdmin: false` — every call gated by `scopes` (see TokenScope).
|
|
43795
|
-
*
|
|
43796
|
-
* No role enum. There used to be `viewer / agent / scoped` and earlier
|
|
43797
|
-
* `super_admin` — collapsed onto the single boolean because every
|
|
43798
|
-
* non-admin caller is governed by the same scope-check rules; the
|
|
43799
|
-
* distinction was only ever used to route role-specific procedures
|
|
43800
|
-
* which we no longer have. CLI / webhook integrations are `cst_*` tokens
|
|
43801
|
-
* with `isAdmin: false` + an explicit scope list.
|
|
43802
|
-
*/
|
|
43803
|
-
/** Per-method access flavour. Materialised on every cap method via codegen. */
|
|
43804
|
-
var MethodAccessSchema = _enum([
|
|
43805
|
-
"view",
|
|
43806
|
-
"create",
|
|
43807
|
-
"delete"
|
|
43808
|
-
]);
|
|
43809
|
-
/**
|
|
43810
|
-
* A single scope grant. Three forms — checked in matcher with OR
|
|
43811
|
-
* semantics; the first match decides whether the call passes:
|
|
43812
|
-
*
|
|
43813
|
-
* - `category` — broadest. `target: 'device' | 'system'` selects every
|
|
43814
|
-
* cap with the matching `scope` declaration. New caps inherit grants
|
|
43815
|
-
* automatically — adding a device cap to the codebase makes it
|
|
43816
|
-
* reachable to every user with `category:device [...]` without a
|
|
43817
|
-
* re-grant. Use this for "family viewer" / "operator" tiers.
|
|
43818
|
-
*
|
|
43819
|
-
* - `addon` — every cap that ships inside a given addon id. Niche;
|
|
43820
|
-
* useful when an integration needs to interact with one specific
|
|
43821
|
-
* addon's surface regardless of how many caps it exports.
|
|
43822
|
-
*
|
|
43823
|
-
* - `capability` — the most precise form. Single cap name. Use for
|
|
43824
|
-
* integration tokens where you want to grant `addons.installPackage`
|
|
43825
|
-
* and nothing else.
|
|
43826
|
-
*
|
|
43827
|
-
* `access` is REQUIRED with min 1 element. `admin` bypass is the
|
|
43828
|
-
* "give me everything" escape; there is no wildcard scope.
|
|
43829
|
-
*/
|
|
43830
|
-
var AllowedProviderSchema = union([literal("*"), array(string())]);
|
|
43831
|
-
var AllowedDevicesSchema = record(string(), union([literal("*"), array(string())]));
|
|
43832
|
-
var CapScopeSchema = _enum(["device", "system"]);
|
|
43833
|
-
/**
|
|
43834
|
-
* DeviceSelector (scope model v3 — 2026-08-12).
|
|
43835
|
-
*
|
|
43836
|
-
* A `device` grant no longer carries a frozen list of deviceIds. It carries
|
|
43837
|
-
* a SELECTOR the matcher resolves against the live fleet, so the grant can be
|
|
43838
|
-
* DYNAMIC: a `types:['camera']` selector automatically covers a camera added
|
|
43839
|
-
* AFTER the grant was minted — no re-grant, no re-login.
|
|
43840
|
-
*
|
|
43841
|
-
* - `all` — every device in the deployment. The broad viewer/operator
|
|
43842
|
-
* lever without a `category` grant (a `category` grant also covers device
|
|
43843
|
-
* caps that carry no deviceId; `all` is specifically the device set).
|
|
43844
|
-
* - `ids` — an explicit deviceId list. This is what a v2 `device:[…]`
|
|
43845
|
-
* grant migrates to (see {@link TokenScopeSchema}); STATIC — a new camera
|
|
43846
|
-
* is NOT covered until the grant is edited.
|
|
43847
|
-
* - `types` — every device of a `DeviceType` (e.g. every `camera`).
|
|
43848
|
-
* DYNAMIC. A device that changes type, or a new device of the type,
|
|
43849
|
-
* re-resolves on the next request.
|
|
43850
|
-
* - `locations` — every device whose operator-assigned `location` label is
|
|
43851
|
-
* in the set (e.g. "Garden", "Front door"). DYNAMIC. A device with a
|
|
43852
|
-
* null/unset location matches NO `locations` selector.
|
|
43853
|
-
*/
|
|
43854
|
-
var DeviceSelectorSchema = discriminatedUnion("kind", [
|
|
43855
|
-
object({ kind: literal("all") }),
|
|
43856
|
-
object({
|
|
43857
|
-
kind: literal("ids"),
|
|
43858
|
-
ids: array(number().int()).min(1)
|
|
43859
|
-
}),
|
|
43860
|
-
object({
|
|
43861
|
-
kind: literal("types"),
|
|
43862
|
-
types: array(_enum(DeviceType)).min(1)
|
|
43863
|
-
}),
|
|
43864
|
-
object({
|
|
43865
|
-
kind: literal("locations"),
|
|
43866
|
-
locations: array(string().min(1)).min(1)
|
|
43867
|
-
})
|
|
43868
|
-
]);
|
|
43869
|
-
var DeviceTokenScopeSchema = object({
|
|
43870
|
-
type: literal("device"),
|
|
43871
|
-
/** The device SET this grant covers — resolved against the live fleet. */
|
|
43872
|
-
selector: DeviceSelectorSchema,
|
|
43873
|
-
access: array(MethodAccessSchema).min(1),
|
|
43874
|
-
/**
|
|
43875
|
-
* Whether a grant on a PARENT device transparently covers its accessory
|
|
43876
|
-
* CHILDREN (siren / floodlight / PIR) via the persisted-parentage walk.
|
|
43877
|
-
* Direction is parent → children ONLY.
|
|
43878
|
-
*
|
|
43879
|
-
* Absent → the matcher DERIVES it from the access flavour: `view`
|
|
43880
|
-
* inherits (a camera viewer sees the camera's accessories), `create` /
|
|
43881
|
-
* `delete` do NOT (actuating/removing a child is an explicit act the
|
|
43882
|
-
* operator must grant on the child, not inherit from the parent). Set it
|
|
43883
|
-
* explicitly to override that default per grant.
|
|
43884
|
-
*/
|
|
43885
|
-
includeLinked: boolean().optional()
|
|
43886
|
-
});
|
|
43887
|
-
/**
|
|
43888
|
-
* v2 → v3 lazy migration. A pre-v3 `device` grant carried
|
|
43889
|
-
* `targets: string[]` (stringified deviceIds); it rewrites to the equivalent
|
|
43890
|
-
* `selector: {kind:'ids', ids}`. Applied as a `preprocess` so it runs on
|
|
43891
|
-
* EVERY parse path — stored records AND the JWT-carried scope arrays
|
|
43892
|
-
* normalised at the request boundary ({@link normalizeTokenScopes} in
|
|
43893
|
-
* `device-selector.ts`). Chosen over a one-time DB migration because a
|
|
43894
|
-
* migration cannot reach a JWT already in a client's hands; parse-time
|
|
43895
|
-
* migration covers both without a flag day. No cast — the raw object is read
|
|
43896
|
-
* through `Reflect.get` (its static type is `unknown`).
|
|
43897
|
-
*/
|
|
43898
|
-
function migrateLegacyTokenScope(raw) {
|
|
43899
|
-
if (raw === null || typeof raw !== "object" || Array.isArray(raw)) return raw;
|
|
43900
|
-
if (Reflect.get(raw, "type") !== "device") return raw;
|
|
43901
|
-
if (Reflect.get(raw, "selector") !== void 0) return raw;
|
|
43902
|
-
const targets = Reflect.get(raw, "targets");
|
|
43903
|
-
if (!Array.isArray(targets)) return raw;
|
|
43904
|
-
return {
|
|
43905
|
-
type: "device",
|
|
43906
|
-
selector: {
|
|
43907
|
-
kind: "ids",
|
|
43908
|
-
ids: targets.map((t) => typeof t === "string" ? Number(t) : t).filter((n) => typeof n === "number" && Number.isInteger(n))
|
|
43909
|
-
},
|
|
43910
|
-
access: Reflect.get(raw, "access")
|
|
43911
|
-
};
|
|
43912
|
-
}
|
|
43913
|
-
var TokenScopeSchema = preprocess(migrateLegacyTokenScope, discriminatedUnion("type", [
|
|
43914
|
-
object({
|
|
43915
|
-
type: literal("category"),
|
|
43916
|
-
target: CapScopeSchema,
|
|
43917
|
-
access: array(MethodAccessSchema).min(1)
|
|
43918
|
-
}),
|
|
43919
|
-
object({
|
|
43920
|
-
type: literal("capability"),
|
|
43921
|
-
target: string(),
|
|
43922
|
-
access: array(MethodAccessSchema).min(1)
|
|
43923
|
-
}),
|
|
43924
|
-
object({
|
|
43925
|
-
type: literal("addon"),
|
|
43926
|
-
target: string(),
|
|
43927
|
-
access: array(MethodAccessSchema).min(1)
|
|
43928
|
-
}),
|
|
43929
|
-
DeviceTokenScopeSchema
|
|
43930
|
-
]));
|
|
43931
|
-
object({
|
|
43932
|
-
id: string(),
|
|
43933
|
-
username: string(),
|
|
43934
|
-
passwordHash: string(),
|
|
43935
|
-
/**
|
|
43936
|
-
* Admin bypass. When true, the middleware skips the scope-access
|
|
43937
|
-
* check entirely. There is no other axis of privilege; the legacy
|
|
43938
|
-
* role enum collapsed onto this boolean in v2.
|
|
43939
|
-
*/
|
|
43940
|
-
isAdmin: boolean().default(false),
|
|
43941
|
-
allowedProviders: AllowedProviderSchema,
|
|
43942
|
-
allowedDevices: AllowedDevicesSchema,
|
|
43943
|
-
/**
|
|
43944
|
-
* Scopes granted to this user. Admins bypass; their `scopes` is
|
|
43945
|
-
* ignored. Non-admins without scopes are locked out of every
|
|
43946
|
-
* protected call.
|
|
43947
|
-
*/
|
|
43948
|
-
scopes: array(TokenScopeSchema).default([]),
|
|
43949
|
-
createdAt: number(),
|
|
43950
|
-
updatedAt: number()
|
|
43951
|
-
});
|
|
43952
|
-
object({
|
|
43953
|
-
id: string(),
|
|
43954
|
-
label: string(),
|
|
43955
|
-
isAdmin: boolean().default(false),
|
|
43956
|
-
allowedProviders: AllowedProviderSchema,
|
|
43957
|
-
allowedDevices: AllowedDevicesSchema,
|
|
43958
|
-
tokenHash: string(),
|
|
43959
|
-
tokenPrefix: string(),
|
|
43960
|
-
createdAt: number(),
|
|
43961
|
-
lastUsedAt: number().optional()
|
|
43962
|
-
});
|
|
43963
|
-
object({
|
|
43964
|
-
id: string(),
|
|
43965
|
-
userId: string(),
|
|
43966
|
-
name: string(),
|
|
43967
|
-
tokenHash: string(),
|
|
43968
|
-
tokenPrefix: string(),
|
|
43969
|
-
scopes: array(TokenScopeSchema),
|
|
43970
|
-
expiresAt: number().nullish(),
|
|
43971
|
-
lastUsedAt: number().nullish(),
|
|
43972
|
-
createdAt: number()
|
|
43973
|
-
});
|
|
43974
|
-
/**
|
|
43975
44027
|
* `oauth-integration` — a collection cap by which an addon declares
|
|
43976
44028
|
* itself a linkable OAuth client of the hub's core `/oauth2/*` server.
|
|
43977
44029
|
* Each provider returns a static descriptor; the core enumerates them
|
|
@@ -50789,7 +50841,10 @@ method(StorageMigrationInputSchema, StorageMigrationPlanSchema, { auth: "admin"
|
|
|
50789
50841
|
}), method(object({ jobId: string().optional() }), StorageMigrationJobSchema.nullable(), { auth: "admin" }), method(object({ jobId: string() }), object({ cancelled: boolean() }), {
|
|
50790
50842
|
kind: "mutation",
|
|
50791
50843
|
auth: "admin"
|
|
50792
|
-
}), method(object({}), array(StorageMigrationMoverSchema).readonly(), { auth: "admin" }), method(object({
|
|
50844
|
+
}), method(object({}), array(StorageMigrationMoverSchema).readonly(), { auth: "admin" }), method(object({ locationIds: array(string()).readonly() }), object({
|
|
50845
|
+
clear: boolean(),
|
|
50846
|
+
repointLocationId: string().optional()
|
|
50847
|
+
}), { auth: "admin" }), method(object({}), array(StorageMigrationResidueSchema).readonly(), { auth: "admin" }), method(StorageMigrationDrainInputSchema, object({ jobId: string() }), {
|
|
50793
50848
|
kind: "mutation",
|
|
50794
50849
|
auth: "admin"
|
|
50795
50850
|
}), method(StorageCleanupInputSchema, object({ jobId: string() }), {
|
|
@@ -54236,6 +54291,11 @@ object({
|
|
|
54236
54291
|
*
|
|
54237
54292
|
* `kind: 'poll'` — cloud REST APIs typically have no push channel; the
|
|
54238
54293
|
* provider refreshes the slice on an interval and eagerly after commands.
|
|
54294
|
+
*
|
|
54295
|
+
* UNKNOWN IS NOT OFF. Every field the appliance reports separately is
|
|
54296
|
+
* nullable: `null` means "not known right now" (the appliance has not said,
|
|
54297
|
+
* the link is down, or the description does not carry it) and is never
|
|
54298
|
+
* rendered or exported as `false` / `0`. `availability` says why.
|
|
54239
54299
|
*/
|
|
54240
54300
|
var DishwasherStateSchema = _enum([
|
|
54241
54301
|
"idle",
|
|
@@ -54245,112 +54305,227 @@ var DishwasherStateSchema = _enum([
|
|
|
54245
54305
|
"error",
|
|
54246
54306
|
"unavailable"
|
|
54247
54307
|
]);
|
|
54308
|
+
/**
|
|
54309
|
+
* The appliance's own operation state, uncollapsed. `state` above is the coarse
|
|
54310
|
+
* view for compact surfaces; this is what the appliance said.
|
|
54311
|
+
*/
|
|
54312
|
+
var DishwasherOperationStateSchema = _enum([
|
|
54313
|
+
"Inactive",
|
|
54314
|
+
"Ready",
|
|
54315
|
+
"DelayedStart",
|
|
54316
|
+
"Run",
|
|
54317
|
+
"Pause",
|
|
54318
|
+
"ActionRequired",
|
|
54319
|
+
"Finished",
|
|
54320
|
+
"Error",
|
|
54321
|
+
"Aborting"
|
|
54322
|
+
]);
|
|
54323
|
+
/**
|
|
54324
|
+
* Why fields may be `null`:
|
|
54325
|
+
* - `available` — the link is up and the description is loaded;
|
|
54326
|
+
* - `offline` — the local link is down (values are unknown, not last-known);
|
|
54327
|
+
* - `description-missing` — the link is up but the appliance's description could not
|
|
54328
|
+
* be loaded, so its values cannot be decoded.
|
|
54329
|
+
*/
|
|
54330
|
+
var DishwasherAvailabilitySchema = _enum([
|
|
54331
|
+
"available",
|
|
54332
|
+
"offline",
|
|
54333
|
+
"description-missing"
|
|
54334
|
+
]);
|
|
54248
54335
|
var DishwasherConsumableLevelSchema = _enum([
|
|
54249
54336
|
"ok",
|
|
54250
54337
|
"low",
|
|
54251
54338
|
"empty"
|
|
54252
54339
|
]);
|
|
54253
54340
|
object({
|
|
54341
|
+
availability: DishwasherAvailabilitySchema,
|
|
54342
|
+
/** Coarse state for compact surfaces; `unavailable` whenever the appliance state is not known. */
|
|
54254
54343
|
state: DishwasherStateSchema,
|
|
54255
|
-
/**
|
|
54344
|
+
/** The appliance's operation state as reported; null when not known. */
|
|
54345
|
+
operationState: DishwasherOperationStateSchema.nullable(),
|
|
54346
|
+
/** Feature key of the ACTIVE (running) program, or null when none runs / not known. */
|
|
54256
54347
|
program: string().nullable(),
|
|
54257
|
-
/**
|
|
54348
|
+
/** Feature key of the SELECTED program (what Start would run), or null when none / not known. */
|
|
54349
|
+
selectedProgram: string().nullable(),
|
|
54350
|
+
/** Feature keys of the programs the appliance currently offers — drives the UI selector. */
|
|
54258
54351
|
availablePrograms: array(string()),
|
|
54259
|
-
/**
|
|
54260
|
-
|
|
54352
|
+
/** Seconds remaining on the active cycle, or null when not running / not known. */
|
|
54353
|
+
remainingSeconds: number().int().nonnegative().nullable(),
|
|
54354
|
+
/** Seconds the delayed start is set to (time until the cycle starts), or null. */
|
|
54355
|
+
delayedStartSeconds: number().int().nonnegative().nullable(),
|
|
54261
54356
|
/** Cycle completion 0..100, or null when not applicable. */
|
|
54262
54357
|
progressPercent: number().min(0).max(100).nullable(),
|
|
54263
|
-
/** True when the door is reported open. */
|
|
54264
|
-
doorOpen: boolean(),
|
|
54265
|
-
/** True when
|
|
54266
|
-
|
|
54267
|
-
/**
|
|
54268
|
-
|
|
54358
|
+
/** True when the door is reported open; null when the door state is not known. */
|
|
54359
|
+
doorOpen: boolean().nullable(),
|
|
54360
|
+
/** True when the door is latched (locked) during a cycle; null when not reported. */
|
|
54361
|
+
doorLocked: boolean().nullable(),
|
|
54362
|
+
/** True when remote start is allowed (door closed, power on, etc.); null when not known. */
|
|
54363
|
+
remoteStartAllowed: boolean().nullable(),
|
|
54364
|
+
/** True when the appliance accepts remote control now; null when not known. */
|
|
54365
|
+
remoteControlActive: boolean().nullable(),
|
|
54366
|
+
/** True while somebody operates the appliance at its panel; null when not reported. */
|
|
54367
|
+
localControlActive: boolean().nullable(),
|
|
54368
|
+
/** Main power / switched-on state; null when not known. */
|
|
54369
|
+
powerOn: boolean().nullable(),
|
|
54370
|
+
/** The raw power state (`On`, `Off`, `Standby`, …); null when not known. */
|
|
54371
|
+
powerState: string().nullable(),
|
|
54269
54372
|
saltLevel: DishwasherConsumableLevelSchema.nullable(),
|
|
54270
54373
|
rinseAidLevel: DishwasherConsumableLevelSchema.nullable(),
|
|
54271
|
-
|
|
54272
|
-
|
|
54374
|
+
/** Option states: null when the appliance does not expose the option or has not said. */
|
|
54375
|
+
halfLoad: boolean().nullable(),
|
|
54376
|
+
hygienePlus: boolean().nullable(),
|
|
54273
54377
|
/** Extra dry option when the appliance exposes it. */
|
|
54274
|
-
extraDry: boolean(),
|
|
54378
|
+
extraDry: boolean().nullable(),
|
|
54275
54379
|
/** Intensive zone (lower basket) when the appliance exposes it. */
|
|
54276
|
-
intensiveZone: boolean(),
|
|
54380
|
+
intensiveZone: boolean().nullable(),
|
|
54277
54381
|
/** VarioSpeed / VarioSpeed+ when the appliance exposes it. */
|
|
54278
|
-
varioSpeedPlus: boolean(),
|
|
54279
|
-
/** Child lock (controls disabled on the appliance). */
|
|
54280
|
-
childLock: boolean(),
|
|
54382
|
+
varioSpeedPlus: boolean().nullable(),
|
|
54383
|
+
/** Child lock (controls disabled on the appliance); null when not known. */
|
|
54384
|
+
childLock: boolean().nullable(),
|
|
54385
|
+
/** Feature keys of the events currently raised (salt low, rinse aid low, program finished, …). */
|
|
54386
|
+
activeEvents: array(string()),
|
|
54387
|
+
/** Numeric error code when the appliance reports one; null otherwise. */
|
|
54281
54388
|
errorCode: number().nullable(),
|
|
54389
|
+
/** Name of the raised alert-level event while the appliance is in error; null otherwise. */
|
|
54282
54390
|
errorLabel: string().nullable(),
|
|
54391
|
+
/** Ms epoch of the last value received from the appliance; 0 = never. */
|
|
54283
54392
|
lastFetchedAt: number()
|
|
54284
54393
|
});
|
|
54285
|
-
|
|
54394
|
+
var DeviceIdSchema = number().int().nonnegative();
|
|
54395
|
+
/** A value a program option or setting can take. */
|
|
54396
|
+
var DishwasherValueSchema = union([
|
|
54397
|
+
boolean(),
|
|
54398
|
+
string(),
|
|
54399
|
+
number()
|
|
54400
|
+
]);
|
|
54401
|
+
var DishwasherAccessSchema = _enum([
|
|
54402
|
+
"none",
|
|
54403
|
+
"read",
|
|
54404
|
+
"readWrite",
|
|
54405
|
+
"writeOnly",
|
|
54406
|
+
"readStatic"
|
|
54407
|
+
]);
|
|
54408
|
+
/**
|
|
54409
|
+
* One option or setting the appliance declares, with the constraints its description
|
|
54410
|
+
* gives. A `readWrite` descriptor that is `available` is what `setOption` accepts.
|
|
54411
|
+
*/
|
|
54412
|
+
var DishwasherOptionDescriptorSchema = object({
|
|
54413
|
+
/** Feature key (`Dishcare.Dishwasher.Option.ExtraDry`). */
|
|
54414
|
+
key: string(),
|
|
54415
|
+
/** Last segment of the key, for display. */
|
|
54416
|
+
name: string(),
|
|
54417
|
+
type: _enum([
|
|
54418
|
+
"boolean",
|
|
54419
|
+
"number",
|
|
54420
|
+
"enum",
|
|
54421
|
+
"string"
|
|
54422
|
+
]),
|
|
54423
|
+
access: DishwasherAccessSchema,
|
|
54424
|
+
/** The appliance reports this entity as currently available. */
|
|
54425
|
+
available: boolean(),
|
|
54426
|
+
/** Unit the description declares for a number; null when it declares none. */
|
|
54427
|
+
unit: string().nullable(),
|
|
54428
|
+
min: number().nullable(),
|
|
54429
|
+
max: number().nullable(),
|
|
54430
|
+
step: number().nullable(),
|
|
54431
|
+
/** Allowed members of an enum; null for other types. */
|
|
54432
|
+
enumValues: array(string()).nullable(),
|
|
54433
|
+
defaultValue: DishwasherValueSchema.nullable()
|
|
54434
|
+
});
|
|
54435
|
+
var DishwasherProgramSchema = object({
|
|
54436
|
+
/** Feature key (`Dishcare.Dishwasher.Program.Eco50`) — what `setProgram` / `start` take. */
|
|
54437
|
+
key: string(),
|
|
54438
|
+
name: string(),
|
|
54439
|
+
/** The appliance currently offers this program. */
|
|
54440
|
+
available: boolean(),
|
|
54441
|
+
/** The options this program lists, with the program-level access / availability / default. */
|
|
54442
|
+
options: array(DishwasherOptionDescriptorSchema)
|
|
54443
|
+
});
|
|
54444
|
+
var DishwasherOptionsSchema = object({
|
|
54445
|
+
availability: DishwasherAvailabilitySchema,
|
|
54446
|
+
/** What the appliance can be told to do, from the commands its description declares. */
|
|
54447
|
+
supportsStart: boolean(),
|
|
54448
|
+
supportsPause: boolean(),
|
|
54449
|
+
supportsResume: boolean(),
|
|
54450
|
+
supportsStop: boolean(),
|
|
54451
|
+
supportsPower: boolean(),
|
|
54452
|
+
/** Every program the description lists, with its options. */
|
|
54453
|
+
programs: array(DishwasherProgramSchema),
|
|
54454
|
+
/** Every option and setting entity the description lists (programs reference these by key). */
|
|
54455
|
+
options: array(DishwasherOptionDescriptorSchema)
|
|
54456
|
+
});
|
|
54457
|
+
DeviceType.Dishwasher, method(object({
|
|
54458
|
+
deviceId: DeviceIdSchema,
|
|
54459
|
+
program: string().min(1).optional(),
|
|
54460
|
+
options: record(string(), DishwasherValueSchema).optional()
|
|
54461
|
+
}), _void(), {
|
|
54286
54462
|
kind: "mutation",
|
|
54287
54463
|
auth: "protected"
|
|
54288
|
-
}), method(object({ deviceId:
|
|
54464
|
+
}), method(object({ deviceId: DeviceIdSchema }), _void(), {
|
|
54289
54465
|
kind: "mutation",
|
|
54290
54466
|
auth: "protected"
|
|
54291
|
-
}), method(object({ deviceId:
|
|
54467
|
+
}), method(object({ deviceId: DeviceIdSchema }), _void(), {
|
|
54468
|
+
kind: "mutation",
|
|
54469
|
+
auth: "protected"
|
|
54470
|
+
}), method(object({ deviceId: DeviceIdSchema }), _void(), {
|
|
54292
54471
|
kind: "mutation",
|
|
54293
54472
|
auth: "protected"
|
|
54294
54473
|
}), method(object({
|
|
54295
|
-
deviceId:
|
|
54474
|
+
deviceId: DeviceIdSchema,
|
|
54296
54475
|
program: string().min(1)
|
|
54297
54476
|
}), _void(), {
|
|
54298
54477
|
kind: "mutation",
|
|
54299
54478
|
auth: "protected"
|
|
54300
54479
|
}), method(object({
|
|
54301
|
-
deviceId:
|
|
54480
|
+
deviceId: DeviceIdSchema,
|
|
54302
54481
|
on: boolean()
|
|
54303
54482
|
}), _void(), {
|
|
54304
54483
|
kind: "mutation",
|
|
54305
54484
|
auth: "protected"
|
|
54306
54485
|
}), method(object({
|
|
54307
|
-
deviceId:
|
|
54486
|
+
deviceId: DeviceIdSchema,
|
|
54308
54487
|
on: boolean()
|
|
54309
54488
|
}), _void(), {
|
|
54310
54489
|
kind: "mutation",
|
|
54311
54490
|
auth: "protected"
|
|
54312
54491
|
}), method(object({
|
|
54313
|
-
deviceId:
|
|
54492
|
+
deviceId: DeviceIdSchema,
|
|
54314
54493
|
on: boolean()
|
|
54315
54494
|
}), _void(), {
|
|
54316
54495
|
kind: "mutation",
|
|
54317
54496
|
auth: "protected"
|
|
54318
54497
|
}), method(object({
|
|
54319
|
-
deviceId:
|
|
54498
|
+
deviceId: DeviceIdSchema,
|
|
54320
54499
|
on: boolean()
|
|
54321
54500
|
}), _void(), {
|
|
54322
54501
|
kind: "mutation",
|
|
54323
54502
|
auth: "protected"
|
|
54324
54503
|
}), method(object({
|
|
54325
|
-
deviceId:
|
|
54504
|
+
deviceId: DeviceIdSchema,
|
|
54326
54505
|
on: boolean()
|
|
54327
54506
|
}), _void(), {
|
|
54328
54507
|
kind: "mutation",
|
|
54329
54508
|
auth: "protected"
|
|
54330
54509
|
}), method(object({
|
|
54331
|
-
deviceId:
|
|
54510
|
+
deviceId: DeviceIdSchema,
|
|
54332
54511
|
on: boolean()
|
|
54333
54512
|
}), _void(), {
|
|
54334
54513
|
kind: "mutation",
|
|
54335
54514
|
auth: "protected"
|
|
54336
54515
|
}), method(object({
|
|
54337
|
-
deviceId:
|
|
54516
|
+
deviceId: DeviceIdSchema,
|
|
54338
54517
|
on: boolean()
|
|
54339
54518
|
}), _void(), {
|
|
54340
54519
|
kind: "mutation",
|
|
54341
54520
|
auth: "protected"
|
|
54342
54521
|
}), method(object({
|
|
54343
|
-
deviceId:
|
|
54522
|
+
deviceId: DeviceIdSchema,
|
|
54344
54523
|
key: string().min(1),
|
|
54345
|
-
value:
|
|
54346
|
-
boolean(),
|
|
54347
|
-
string(),
|
|
54348
|
-
number()
|
|
54349
|
-
])
|
|
54524
|
+
value: DishwasherValueSchema
|
|
54350
54525
|
}), _void(), {
|
|
54351
54526
|
kind: "mutation",
|
|
54352
54527
|
auth: "protected"
|
|
54353
|
-
});
|
|
54528
|
+
}), method(object({ deviceId: DeviceIdSchema }), DishwasherOptionsSchema, { auth: "protected" });
|
|
54354
54529
|
object({
|
|
54355
54530
|
/** Ms epoch of the last press. null = never observed since this provider started. */
|
|
54356
54531
|
lastPressedAt: number().nullable(),
|
|
@@ -64417,6 +64592,12 @@ Object.freeze({
|
|
|
64417
64592
|
addonId: null,
|
|
64418
64593
|
access: "view"
|
|
64419
64594
|
},
|
|
64595
|
+
"dishwasher.getOptions": {
|
|
64596
|
+
capName: "dishwasher",
|
|
64597
|
+
capScope: "device",
|
|
64598
|
+
addonId: null,
|
|
64599
|
+
access: "view"
|
|
64600
|
+
},
|
|
64420
64601
|
"dishwasher.getStatus": {
|
|
64421
64602
|
capName: "dishwasher",
|
|
64422
64603
|
capScope: "device",
|
|
@@ -64429,6 +64610,12 @@ Object.freeze({
|
|
|
64429
64610
|
addonId: null,
|
|
64430
64611
|
access: "create"
|
|
64431
64612
|
},
|
|
64613
|
+
"dishwasher.resume": {
|
|
64614
|
+
capName: "dishwasher",
|
|
64615
|
+
capScope: "device",
|
|
64616
|
+
addonId: null,
|
|
64617
|
+
access: "create"
|
|
64618
|
+
},
|
|
64432
64619
|
"dishwasher.setChildLock": {
|
|
64433
64620
|
capName: "dishwasher",
|
|
64434
64621
|
capScope: "device",
|
|
@@ -68929,6 +69116,12 @@ Object.freeze({
|
|
|
68929
69116
|
addonId: null,
|
|
68930
69117
|
access: "view"
|
|
68931
69118
|
},
|
|
69119
|
+
"storageMigration.moverClearance": {
|
|
69120
|
+
capName: "storage-migration",
|
|
69121
|
+
capScope: "system",
|
|
69122
|
+
addonId: null,
|
|
69123
|
+
access: "view"
|
|
69124
|
+
},
|
|
68932
69125
|
"storageMigration.movers": {
|
|
68933
69126
|
capName: "storage-migration",
|
|
68934
69127
|
capScope: "system",
|
|
@@ -71122,6 +71315,11 @@ Object.freeze({
|
|
|
71122
71315
|
form: "single",
|
|
71123
71316
|
optional: false
|
|
71124
71317
|
}],
|
|
71318
|
+
"dishwasher.getOptions": [{
|
|
71319
|
+
name: "deviceId",
|
|
71320
|
+
form: "single",
|
|
71321
|
+
optional: false
|
|
71322
|
+
}],
|
|
71125
71323
|
"dishwasher.getStatus": [{
|
|
71126
71324
|
name: "deviceId",
|
|
71127
71325
|
form: "single",
|
|
@@ -71132,6 +71330,11 @@ Object.freeze({
|
|
|
71132
71330
|
form: "single",
|
|
71133
71331
|
optional: false
|
|
71134
71332
|
}],
|
|
71333
|
+
"dishwasher.resume": [{
|
|
71334
|
+
name: "deviceId",
|
|
71335
|
+
form: "single",
|
|
71336
|
+
optional: false
|
|
71337
|
+
}],
|
|
71135
71338
|
"dishwasher.setChildLock": [{
|
|
71136
71339
|
name: "deviceId",
|
|
71137
71340
|
form: "single",
|
|
@@ -73218,6 +73421,9 @@ new Map(Object.entries({
|
|
|
73218
73421
|
"wrapper-update-available": "system",
|
|
73219
73422
|
"backup-completed": "system",
|
|
73220
73423
|
"export-completed": "system",
|
|
73424
|
+
"alert-critical": "system",
|
|
73425
|
+
"alert-error": "system",
|
|
73426
|
+
"alert-critical-resolved": "system",
|
|
73221
73427
|
"storage-location-low": "system",
|
|
73222
73428
|
"storage-location-critical": "system",
|
|
73223
73429
|
"storage-location-ok": "system",
|
|
@@ -73342,6 +73548,16 @@ var NC_SYSTEM_EVENT_KIND_GROUP_SPECS = [
|
|
|
73342
73548
|
"storage-location-ok"
|
|
73343
73549
|
]
|
|
73344
73550
|
},
|
|
73551
|
+
{
|
|
73552
|
+
id: "alerts",
|
|
73553
|
+
family: "system",
|
|
73554
|
+
label: "Alerts",
|
|
73555
|
+
kinds: [
|
|
73556
|
+
"alert-critical",
|
|
73557
|
+
"alert-error",
|
|
73558
|
+
"alert-critical-resolved"
|
|
73559
|
+
]
|
|
73560
|
+
},
|
|
73345
73561
|
{
|
|
73346
73562
|
id: "alarm",
|
|
73347
73563
|
family: "alarm",
|
|
@@ -73386,6 +73602,21 @@ var NC_SENSOR_RAISED_FIELD_BY_KIND = Object.freeze(Object.fromEntries(Object.ent
|
|
|
73386
73602
|
return [[descriptor.kind, field]];
|
|
73387
73603
|
})));
|
|
73388
73604
|
Object.freeze(Object.keys(NC_SENSOR_RAISED_FIELD_BY_KIND));
|
|
73605
|
+
object({
|
|
73606
|
+
phase: _enum(["raised", "resolved"]),
|
|
73607
|
+
episodeId: string().min(1),
|
|
73608
|
+
alertId: string().min(1),
|
|
73609
|
+
severity: AlertSeveritySchema,
|
|
73610
|
+
category: string(),
|
|
73611
|
+
title: string(),
|
|
73612
|
+
message: string(),
|
|
73613
|
+
sourceType: string().optional(),
|
|
73614
|
+
sourceId: string().optional(),
|
|
73615
|
+
nodeId: string().optional(),
|
|
73616
|
+
/** The alert's own action link (where the operator acts on it), when it has one. */
|
|
73617
|
+
actionUrl: string().optional(),
|
|
73618
|
+
at: number()
|
|
73619
|
+
});
|
|
73389
73620
|
var RULE_BODY_ONLY = ["body"];
|
|
73390
73621
|
var RULE_TEXT = ["title", "body"];
|
|
73391
73622
|
var BATTERY = ["device-battery-low", "device-battery-normal"];
|
|
@@ -73395,6 +73626,11 @@ var TANK = [
|
|
|
73395
73626
|
"device-tank-full",
|
|
73396
73627
|
"device-tank-normal"
|
|
73397
73628
|
];
|
|
73629
|
+
var ALERT_EPISODE = [
|
|
73630
|
+
"alert-critical",
|
|
73631
|
+
"alert-error",
|
|
73632
|
+
"alert-critical-resolved"
|
|
73633
|
+
];
|
|
73398
73634
|
var UPDATES = [
|
|
73399
73635
|
"addon-update-available",
|
|
73400
73636
|
"server-update-available",
|
|
@@ -73587,14 +73823,14 @@ var STATE_SUMMARY_VARS = [
|
|
|
73587
73823
|
([...RULE_TEXT], [...CONSUMABLE]),
|
|
73588
73824
|
([...RULE_TEXT], [...TANK]),
|
|
73589
73825
|
[...RULE_TEXT],
|
|
73590
|
-
([...RULE_TEXT], [...UPDATES]),
|
|
73591
|
-
([...RULE_TEXT], [...UPDATES]),
|
|
73592
|
-
[...RULE_TEXT],
|
|
73826
|
+
([...RULE_TEXT], [...UPDATES, ...ALERT_EPISODE]),
|
|
73827
|
+
([...RULE_TEXT], [...UPDATES, ...ALERT_EPISODE]),
|
|
73593
73828
|
[...RULE_TEXT],
|
|
73594
73829
|
[...RULE_TEXT],
|
|
73595
73830
|
[...RULE_TEXT],
|
|
73596
73831
|
[...RULE_TEXT],
|
|
73597
73832
|
[...RULE_TEXT],
|
|
73833
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
73598
73834
|
[...RULE_TEXT],
|
|
73599
73835
|
[...RULE_TEXT],
|
|
73600
73836
|
[...RULE_TEXT],
|
|
@@ -73612,7 +73848,11 @@ var STATE_SUMMARY_VARS = [
|
|
|
73612
73848
|
[...RULE_TEXT],
|
|
73613
73849
|
[...RULE_TEXT],
|
|
73614
73850
|
[...RULE_TEXT],
|
|
73615
|
-
[...RULE_TEXT],
|
|
73851
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
73852
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
73853
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
73854
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
73855
|
+
([...RULE_TEXT], [...ALERT_EPISODE]),
|
|
73616
73856
|
[...RULE_TEXT],
|
|
73617
73857
|
[...RULE_TEXT],
|
|
73618
73858
|
[...RULE_TEXT],
|