@camstack/addon-notifiers 1.2.55 → 1.2.56
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/addon.js +115 -6
- package/dist/addon.mjs +115 -6
- package/package.json +1 -1
package/dist/addon.js
CHANGED
|
@@ -19037,6 +19037,34 @@ var KeyEventsForDeviceSchema = object({
|
|
|
19037
19037
|
deviceId: number(),
|
|
19038
19038
|
events: array(KeyEventSchema).readonly()
|
|
19039
19039
|
});
|
|
19040
|
+
/** One non-empty bucket of the timeline histogram. */
|
|
19041
|
+
var EventDensityBucketSchema = object({
|
|
19042
|
+
bucketStart: number(),
|
|
19043
|
+
motion: number().int(),
|
|
19044
|
+
object: number().int(),
|
|
19045
|
+
audio: number().int()
|
|
19046
|
+
});
|
|
19047
|
+
/**
|
|
19048
|
+
* One camera's row in a `getEventDensityBatch` answer.
|
|
19049
|
+
*
|
|
19050
|
+
* TWO facts, and the timeline draws them differently:
|
|
19051
|
+
*
|
|
19052
|
+
* - `read: 'read'` — the histogram for this camera. `buckets: []` is a real
|
|
19053
|
+
* claim: read, and nothing happened in the window.
|
|
19054
|
+
* - `read: 'unreadable'` — nobody could answer for this camera. `buckets` is
|
|
19055
|
+
* empty and that emptiness means NOTHING; the timeline must render unknown,
|
|
19056
|
+
* not quiet.
|
|
19057
|
+
*
|
|
19058
|
+
* Fanned out per camera the difference was free — one query rejected while the
|
|
19059
|
+
* others resolved — and collapsing to a batch is the exact moment it is lost
|
|
19060
|
+
* silently. Every requested id gets a row: a caller that asked for twelve and
|
|
19061
|
+
* got eleven cannot tell which one is missing, or that any is.
|
|
19062
|
+
*/
|
|
19063
|
+
var EventDensityForDeviceSchema = object({
|
|
19064
|
+
deviceId: number(),
|
|
19065
|
+
read: _enum(["read", "unreadable"]),
|
|
19066
|
+
buckets: array(EventDensityBucketSchema).readonly()
|
|
19067
|
+
});
|
|
19040
19068
|
object({
|
|
19041
19069
|
trackId: string(),
|
|
19042
19070
|
className: string(),
|
|
@@ -19347,12 +19375,12 @@ DeviceType.Camera, method(object({ deviceId: number() }), array(TrackSchema).rea
|
|
|
19347
19375
|
since: number(),
|
|
19348
19376
|
until: number(),
|
|
19349
19377
|
bucketMs: number().int().positive()
|
|
19350
|
-
}), array(object({
|
|
19351
|
-
|
|
19352
|
-
|
|
19353
|
-
|
|
19354
|
-
|
|
19355
|
-
})).readonly()), method(object({
|
|
19378
|
+
}), array(EventDensityBucketSchema).readonly()), method(object({
|
|
19379
|
+
deviceIds: array(number()).min(1).max(200),
|
|
19380
|
+
since: number(),
|
|
19381
|
+
until: number(),
|
|
19382
|
+
bucketMs: number().int().positive()
|
|
19383
|
+
}), array(EventDensityForDeviceSchema).readonly()), method(object({
|
|
19356
19384
|
deviceId: number(),
|
|
19357
19385
|
cutoffMs: number()
|
|
19358
19386
|
}), object({
|
|
@@ -26662,6 +26690,39 @@ var RecordingDaysSchema = object({
|
|
|
26662
26690
|
/** Local-midnight epochs (UTC ms) of days that have ≥1 recorded segment. */
|
|
26663
26691
|
days: array(number())
|
|
26664
26692
|
});
|
|
26693
|
+
/**
|
|
26694
|
+
* One camera's row in a `getAvailabilityBatch` answer.
|
|
26695
|
+
*
|
|
26696
|
+
* `ranges` is EXACTLY what `getAvailability` returns for that camera — the
|
|
26697
|
+
* batch collapses the transport, not the work — plus the one thing the singular
|
|
26698
|
+
* method never had to say:
|
|
26699
|
+
*
|
|
26700
|
+
* - `read: 'read'` — answered. `ranges: []` means "read, and this camera has
|
|
26701
|
+
* no footage in the window", which is a real claim.
|
|
26702
|
+
* - `read: 'unreadable'` — the recorder could not answer for this camera (its
|
|
26703
|
+
* calendar rung threw, its location is unmounted). `ranges` is empty and
|
|
26704
|
+
* that emptiness means NOTHING.
|
|
26705
|
+
*
|
|
26706
|
+
* A timeline that renders the second as the first tells an operator there is no
|
|
26707
|
+
* footage when the truth is that nobody looked.
|
|
26708
|
+
*/
|
|
26709
|
+
var RecordingAvailabilityForDeviceSchema = object({
|
|
26710
|
+
deviceId: number(),
|
|
26711
|
+
read: _enum(["read", "unreadable"]),
|
|
26712
|
+
ranges: array(RecordingRangeSchema).readonly()
|
|
26713
|
+
});
|
|
26714
|
+
/**
|
|
26715
|
+
* One camera's row in a `getDaysWithRecordingsBatch` answer. Same rule as
|
|
26716
|
+
* {@link RecordingAvailabilityForDeviceSchema}: `days: []` on a `'read'` row is
|
|
26717
|
+
* "no footage in this month", `read: 'unreadable'` is "nobody could look", and
|
|
26718
|
+
* the date-picker's day dots must not spell them the same.
|
|
26719
|
+
*/
|
|
26720
|
+
var RecordingDaysForDeviceSchema = object({
|
|
26721
|
+
deviceId: number(),
|
|
26722
|
+
read: _enum(["read", "unreadable"]),
|
|
26723
|
+
/** Local-midnight epochs (UTC ms) of days that have ≥1 recorded segment. */
|
|
26724
|
+
days: array(number()).readonly()
|
|
26725
|
+
});
|
|
26665
26726
|
var RecordingManifestSchema = object({
|
|
26666
26727
|
deviceId: number(),
|
|
26667
26728
|
/** Local filesystem path to the master playlist; null when no recording exists for the requested range. */
|
|
@@ -26896,6 +26957,13 @@ method(object({
|
|
|
26896
26957
|
}), RecordingAvailabilitySchema, {
|
|
26897
26958
|
kind: "query",
|
|
26898
26959
|
auth: "protected"
|
|
26960
|
+
}), method(object({
|
|
26961
|
+
deviceIds: array(number()).min(1).max(200),
|
|
26962
|
+
fromMs: number(),
|
|
26963
|
+
toMs: number()
|
|
26964
|
+
}), array(RecordingAvailabilityForDeviceSchema).readonly(), {
|
|
26965
|
+
kind: "query",
|
|
26966
|
+
auth: "protected"
|
|
26899
26967
|
}), method(object({
|
|
26900
26968
|
deviceId: number(),
|
|
26901
26969
|
fromMs: number(),
|
|
@@ -26904,6 +26972,14 @@ method(object({
|
|
|
26904
26972
|
}), RecordingDaysSchema, {
|
|
26905
26973
|
kind: "query",
|
|
26906
26974
|
auth: "protected"
|
|
26975
|
+
}), method(object({
|
|
26976
|
+
deviceIds: array(number()).min(1).max(200),
|
|
26977
|
+
fromMs: number(),
|
|
26978
|
+
toMs: number(),
|
|
26979
|
+
tzOffsetMinutes: number()
|
|
26980
|
+
}), array(RecordingDaysForDeviceSchema).readonly(), {
|
|
26981
|
+
kind: "query",
|
|
26982
|
+
auth: "protected"
|
|
26907
26983
|
}), method(object({
|
|
26908
26984
|
deviceId: number(),
|
|
26909
26985
|
fromMs: number(),
|
|
@@ -32101,6 +32177,12 @@ Object.freeze({
|
|
|
32101
32177
|
addonId: null,
|
|
32102
32178
|
access: "view"
|
|
32103
32179
|
},
|
|
32180
|
+
"pipelineAnalytics.getEventDensityBatch": {
|
|
32181
|
+
capName: "pipeline-analytics",
|
|
32182
|
+
capScope: "device",
|
|
32183
|
+
addonId: null,
|
|
32184
|
+
access: "view"
|
|
32185
|
+
},
|
|
32104
32186
|
"pipelineAnalytics.getEventMedia": {
|
|
32105
32187
|
capName: "pipeline-analytics",
|
|
32106
32188
|
capScope: "device",
|
|
@@ -33223,12 +33305,24 @@ Object.freeze({
|
|
|
33223
33305
|
addonId: null,
|
|
33224
33306
|
access: "view"
|
|
33225
33307
|
},
|
|
33308
|
+
"recording.getAvailabilityBatch": {
|
|
33309
|
+
capName: "recording",
|
|
33310
|
+
capScope: "system",
|
|
33311
|
+
addonId: null,
|
|
33312
|
+
access: "view"
|
|
33313
|
+
},
|
|
33226
33314
|
"recording.getDaysWithRecordings": {
|
|
33227
33315
|
capName: "recording",
|
|
33228
33316
|
capScope: "system",
|
|
33229
33317
|
addonId: null,
|
|
33230
33318
|
access: "view"
|
|
33231
33319
|
},
|
|
33320
|
+
"recording.getDaysWithRecordingsBatch": {
|
|
33321
|
+
capName: "recording",
|
|
33322
|
+
capScope: "system",
|
|
33323
|
+
addonId: null,
|
|
33324
|
+
access: "view"
|
|
33325
|
+
},
|
|
33232
33326
|
"recording.getDeviceConfig": {
|
|
33233
33327
|
capName: "recording",
|
|
33234
33328
|
capScope: "system",
|
|
@@ -35833,6 +35927,11 @@ Object.freeze({
|
|
|
35833
35927
|
form: "single",
|
|
35834
35928
|
optional: false
|
|
35835
35929
|
}],
|
|
35930
|
+
"pipelineAnalytics.getEventDensityBatch": [{
|
|
35931
|
+
name: "deviceIds",
|
|
35932
|
+
form: "array",
|
|
35933
|
+
optional: false
|
|
35934
|
+
}],
|
|
35836
35935
|
"pipelineAnalytics.getEventMedia": [{
|
|
35837
35936
|
name: "deviceId",
|
|
35838
35937
|
form: "single",
|
|
@@ -36248,11 +36347,21 @@ Object.freeze({
|
|
|
36248
36347
|
form: "single",
|
|
36249
36348
|
optional: false
|
|
36250
36349
|
}],
|
|
36350
|
+
"recording.getAvailabilityBatch": [{
|
|
36351
|
+
name: "deviceIds",
|
|
36352
|
+
form: "array",
|
|
36353
|
+
optional: false
|
|
36354
|
+
}],
|
|
36251
36355
|
"recording.getDaysWithRecordings": [{
|
|
36252
36356
|
name: "deviceId",
|
|
36253
36357
|
form: "single",
|
|
36254
36358
|
optional: false
|
|
36255
36359
|
}],
|
|
36360
|
+
"recording.getDaysWithRecordingsBatch": [{
|
|
36361
|
+
name: "deviceIds",
|
|
36362
|
+
form: "array",
|
|
36363
|
+
optional: false
|
|
36364
|
+
}],
|
|
36256
36365
|
"recording.getDeviceConfig": [{
|
|
36257
36366
|
name: "deviceId",
|
|
36258
36367
|
form: "single",
|
package/dist/addon.mjs
CHANGED
|
@@ -19010,6 +19010,34 @@ var KeyEventsForDeviceSchema = object({
|
|
|
19010
19010
|
deviceId: number(),
|
|
19011
19011
|
events: array(KeyEventSchema).readonly()
|
|
19012
19012
|
});
|
|
19013
|
+
/** One non-empty bucket of the timeline histogram. */
|
|
19014
|
+
var EventDensityBucketSchema = object({
|
|
19015
|
+
bucketStart: number(),
|
|
19016
|
+
motion: number().int(),
|
|
19017
|
+
object: number().int(),
|
|
19018
|
+
audio: number().int()
|
|
19019
|
+
});
|
|
19020
|
+
/**
|
|
19021
|
+
* One camera's row in a `getEventDensityBatch` answer.
|
|
19022
|
+
*
|
|
19023
|
+
* TWO facts, and the timeline draws them differently:
|
|
19024
|
+
*
|
|
19025
|
+
* - `read: 'read'` — the histogram for this camera. `buckets: []` is a real
|
|
19026
|
+
* claim: read, and nothing happened in the window.
|
|
19027
|
+
* - `read: 'unreadable'` — nobody could answer for this camera. `buckets` is
|
|
19028
|
+
* empty and that emptiness means NOTHING; the timeline must render unknown,
|
|
19029
|
+
* not quiet.
|
|
19030
|
+
*
|
|
19031
|
+
* Fanned out per camera the difference was free — one query rejected while the
|
|
19032
|
+
* others resolved — and collapsing to a batch is the exact moment it is lost
|
|
19033
|
+
* silently. Every requested id gets a row: a caller that asked for twelve and
|
|
19034
|
+
* got eleven cannot tell which one is missing, or that any is.
|
|
19035
|
+
*/
|
|
19036
|
+
var EventDensityForDeviceSchema = object({
|
|
19037
|
+
deviceId: number(),
|
|
19038
|
+
read: _enum(["read", "unreadable"]),
|
|
19039
|
+
buckets: array(EventDensityBucketSchema).readonly()
|
|
19040
|
+
});
|
|
19013
19041
|
object({
|
|
19014
19042
|
trackId: string(),
|
|
19015
19043
|
className: string(),
|
|
@@ -19320,12 +19348,12 @@ DeviceType.Camera, method(object({ deviceId: number() }), array(TrackSchema).rea
|
|
|
19320
19348
|
since: number(),
|
|
19321
19349
|
until: number(),
|
|
19322
19350
|
bucketMs: number().int().positive()
|
|
19323
|
-
}), array(object({
|
|
19324
|
-
|
|
19325
|
-
|
|
19326
|
-
|
|
19327
|
-
|
|
19328
|
-
})).readonly()), method(object({
|
|
19351
|
+
}), array(EventDensityBucketSchema).readonly()), method(object({
|
|
19352
|
+
deviceIds: array(number()).min(1).max(200),
|
|
19353
|
+
since: number(),
|
|
19354
|
+
until: number(),
|
|
19355
|
+
bucketMs: number().int().positive()
|
|
19356
|
+
}), array(EventDensityForDeviceSchema).readonly()), method(object({
|
|
19329
19357
|
deviceId: number(),
|
|
19330
19358
|
cutoffMs: number()
|
|
19331
19359
|
}), object({
|
|
@@ -26635,6 +26663,39 @@ var RecordingDaysSchema = object({
|
|
|
26635
26663
|
/** Local-midnight epochs (UTC ms) of days that have ≥1 recorded segment. */
|
|
26636
26664
|
days: array(number())
|
|
26637
26665
|
});
|
|
26666
|
+
/**
|
|
26667
|
+
* One camera's row in a `getAvailabilityBatch` answer.
|
|
26668
|
+
*
|
|
26669
|
+
* `ranges` is EXACTLY what `getAvailability` returns for that camera — the
|
|
26670
|
+
* batch collapses the transport, not the work — plus the one thing the singular
|
|
26671
|
+
* method never had to say:
|
|
26672
|
+
*
|
|
26673
|
+
* - `read: 'read'` — answered. `ranges: []` means "read, and this camera has
|
|
26674
|
+
* no footage in the window", which is a real claim.
|
|
26675
|
+
* - `read: 'unreadable'` — the recorder could not answer for this camera (its
|
|
26676
|
+
* calendar rung threw, its location is unmounted). `ranges` is empty and
|
|
26677
|
+
* that emptiness means NOTHING.
|
|
26678
|
+
*
|
|
26679
|
+
* A timeline that renders the second as the first tells an operator there is no
|
|
26680
|
+
* footage when the truth is that nobody looked.
|
|
26681
|
+
*/
|
|
26682
|
+
var RecordingAvailabilityForDeviceSchema = object({
|
|
26683
|
+
deviceId: number(),
|
|
26684
|
+
read: _enum(["read", "unreadable"]),
|
|
26685
|
+
ranges: array(RecordingRangeSchema).readonly()
|
|
26686
|
+
});
|
|
26687
|
+
/**
|
|
26688
|
+
* One camera's row in a `getDaysWithRecordingsBatch` answer. Same rule as
|
|
26689
|
+
* {@link RecordingAvailabilityForDeviceSchema}: `days: []` on a `'read'` row is
|
|
26690
|
+
* "no footage in this month", `read: 'unreadable'` is "nobody could look", and
|
|
26691
|
+
* the date-picker's day dots must not spell them the same.
|
|
26692
|
+
*/
|
|
26693
|
+
var RecordingDaysForDeviceSchema = object({
|
|
26694
|
+
deviceId: number(),
|
|
26695
|
+
read: _enum(["read", "unreadable"]),
|
|
26696
|
+
/** Local-midnight epochs (UTC ms) of days that have ≥1 recorded segment. */
|
|
26697
|
+
days: array(number()).readonly()
|
|
26698
|
+
});
|
|
26638
26699
|
var RecordingManifestSchema = object({
|
|
26639
26700
|
deviceId: number(),
|
|
26640
26701
|
/** Local filesystem path to the master playlist; null when no recording exists for the requested range. */
|
|
@@ -26869,6 +26930,13 @@ method(object({
|
|
|
26869
26930
|
}), RecordingAvailabilitySchema, {
|
|
26870
26931
|
kind: "query",
|
|
26871
26932
|
auth: "protected"
|
|
26933
|
+
}), method(object({
|
|
26934
|
+
deviceIds: array(number()).min(1).max(200),
|
|
26935
|
+
fromMs: number(),
|
|
26936
|
+
toMs: number()
|
|
26937
|
+
}), array(RecordingAvailabilityForDeviceSchema).readonly(), {
|
|
26938
|
+
kind: "query",
|
|
26939
|
+
auth: "protected"
|
|
26872
26940
|
}), method(object({
|
|
26873
26941
|
deviceId: number(),
|
|
26874
26942
|
fromMs: number(),
|
|
@@ -26877,6 +26945,14 @@ method(object({
|
|
|
26877
26945
|
}), RecordingDaysSchema, {
|
|
26878
26946
|
kind: "query",
|
|
26879
26947
|
auth: "protected"
|
|
26948
|
+
}), method(object({
|
|
26949
|
+
deviceIds: array(number()).min(1).max(200),
|
|
26950
|
+
fromMs: number(),
|
|
26951
|
+
toMs: number(),
|
|
26952
|
+
tzOffsetMinutes: number()
|
|
26953
|
+
}), array(RecordingDaysForDeviceSchema).readonly(), {
|
|
26954
|
+
kind: "query",
|
|
26955
|
+
auth: "protected"
|
|
26880
26956
|
}), method(object({
|
|
26881
26957
|
deviceId: number(),
|
|
26882
26958
|
fromMs: number(),
|
|
@@ -32074,6 +32150,12 @@ Object.freeze({
|
|
|
32074
32150
|
addonId: null,
|
|
32075
32151
|
access: "view"
|
|
32076
32152
|
},
|
|
32153
|
+
"pipelineAnalytics.getEventDensityBatch": {
|
|
32154
|
+
capName: "pipeline-analytics",
|
|
32155
|
+
capScope: "device",
|
|
32156
|
+
addonId: null,
|
|
32157
|
+
access: "view"
|
|
32158
|
+
},
|
|
32077
32159
|
"pipelineAnalytics.getEventMedia": {
|
|
32078
32160
|
capName: "pipeline-analytics",
|
|
32079
32161
|
capScope: "device",
|
|
@@ -33196,12 +33278,24 @@ Object.freeze({
|
|
|
33196
33278
|
addonId: null,
|
|
33197
33279
|
access: "view"
|
|
33198
33280
|
},
|
|
33281
|
+
"recording.getAvailabilityBatch": {
|
|
33282
|
+
capName: "recording",
|
|
33283
|
+
capScope: "system",
|
|
33284
|
+
addonId: null,
|
|
33285
|
+
access: "view"
|
|
33286
|
+
},
|
|
33199
33287
|
"recording.getDaysWithRecordings": {
|
|
33200
33288
|
capName: "recording",
|
|
33201
33289
|
capScope: "system",
|
|
33202
33290
|
addonId: null,
|
|
33203
33291
|
access: "view"
|
|
33204
33292
|
},
|
|
33293
|
+
"recording.getDaysWithRecordingsBatch": {
|
|
33294
|
+
capName: "recording",
|
|
33295
|
+
capScope: "system",
|
|
33296
|
+
addonId: null,
|
|
33297
|
+
access: "view"
|
|
33298
|
+
},
|
|
33205
33299
|
"recording.getDeviceConfig": {
|
|
33206
33300
|
capName: "recording",
|
|
33207
33301
|
capScope: "system",
|
|
@@ -35806,6 +35900,11 @@ Object.freeze({
|
|
|
35806
35900
|
form: "single",
|
|
35807
35901
|
optional: false
|
|
35808
35902
|
}],
|
|
35903
|
+
"pipelineAnalytics.getEventDensityBatch": [{
|
|
35904
|
+
name: "deviceIds",
|
|
35905
|
+
form: "array",
|
|
35906
|
+
optional: false
|
|
35907
|
+
}],
|
|
35809
35908
|
"pipelineAnalytics.getEventMedia": [{
|
|
35810
35909
|
name: "deviceId",
|
|
35811
35910
|
form: "single",
|
|
@@ -36221,11 +36320,21 @@ Object.freeze({
|
|
|
36221
36320
|
form: "single",
|
|
36222
36321
|
optional: false
|
|
36223
36322
|
}],
|
|
36323
|
+
"recording.getAvailabilityBatch": [{
|
|
36324
|
+
name: "deviceIds",
|
|
36325
|
+
form: "array",
|
|
36326
|
+
optional: false
|
|
36327
|
+
}],
|
|
36224
36328
|
"recording.getDaysWithRecordings": [{
|
|
36225
36329
|
name: "deviceId",
|
|
36226
36330
|
form: "single",
|
|
36227
36331
|
optional: false
|
|
36228
36332
|
}],
|
|
36333
|
+
"recording.getDaysWithRecordingsBatch": [{
|
|
36334
|
+
name: "deviceIds",
|
|
36335
|
+
form: "array",
|
|
36336
|
+
optional: false
|
|
36337
|
+
}],
|
|
36229
36338
|
"recording.getDeviceConfig": [{
|
|
36230
36339
|
name: "deviceId",
|
|
36231
36340
|
form: "single",
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@camstack/addon-notifiers",
|
|
3
|
-
"version": "1.2.
|
|
3
|
+
"version": "1.2.56",
|
|
4
4
|
"description": "System notifiers addon for CamStack — a `notification-output` collection provider hosting per-kind notifier adapters (ntfy, pushover, gotify, telegram, discord, webhook, zentik).",
|
|
5
5
|
"keywords": [
|
|
6
6
|
"camstack",
|