@camstack/addon-notifiers 1.2.54 → 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 +117 -6
- package/dist/addon.mjs +117 -6
- package/package.json +1 -1
package/dist/addon.js
CHANGED
|
@@ -15761,6 +15761,8 @@ var NcSystemEventKindSchema = _enum([
|
|
|
15761
15761
|
"device-offline",
|
|
15762
15762
|
"device-disabled",
|
|
15763
15763
|
"device-enabled",
|
|
15764
|
+
"device-battery-low",
|
|
15765
|
+
"device-battery-normal",
|
|
15764
15766
|
"stream-online",
|
|
15765
15767
|
"stream-offline",
|
|
15766
15768
|
"node-online",
|
|
@@ -19035,6 +19037,34 @@ var KeyEventsForDeviceSchema = object({
|
|
|
19035
19037
|
deviceId: number(),
|
|
19036
19038
|
events: array(KeyEventSchema).readonly()
|
|
19037
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
|
+
});
|
|
19038
19068
|
object({
|
|
19039
19069
|
trackId: string(),
|
|
19040
19070
|
className: string(),
|
|
@@ -19345,12 +19375,12 @@ DeviceType.Camera, method(object({ deviceId: number() }), array(TrackSchema).rea
|
|
|
19345
19375
|
since: number(),
|
|
19346
19376
|
until: number(),
|
|
19347
19377
|
bucketMs: number().int().positive()
|
|
19348
|
-
}), array(object({
|
|
19349
|
-
|
|
19350
|
-
|
|
19351
|
-
|
|
19352
|
-
|
|
19353
|
-
})).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({
|
|
19354
19384
|
deviceId: number(),
|
|
19355
19385
|
cutoffMs: number()
|
|
19356
19386
|
}), object({
|
|
@@ -26660,6 +26690,39 @@ var RecordingDaysSchema = object({
|
|
|
26660
26690
|
/** Local-midnight epochs (UTC ms) of days that have ≥1 recorded segment. */
|
|
26661
26691
|
days: array(number())
|
|
26662
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
|
+
});
|
|
26663
26726
|
var RecordingManifestSchema = object({
|
|
26664
26727
|
deviceId: number(),
|
|
26665
26728
|
/** Local filesystem path to the master playlist; null when no recording exists for the requested range. */
|
|
@@ -26894,6 +26957,13 @@ method(object({
|
|
|
26894
26957
|
}), RecordingAvailabilitySchema, {
|
|
26895
26958
|
kind: "query",
|
|
26896
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"
|
|
26897
26967
|
}), method(object({
|
|
26898
26968
|
deviceId: number(),
|
|
26899
26969
|
fromMs: number(),
|
|
@@ -26902,6 +26972,14 @@ method(object({
|
|
|
26902
26972
|
}), RecordingDaysSchema, {
|
|
26903
26973
|
kind: "query",
|
|
26904
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"
|
|
26905
26983
|
}), method(object({
|
|
26906
26984
|
deviceId: number(),
|
|
26907
26985
|
fromMs: number(),
|
|
@@ -32099,6 +32177,12 @@ Object.freeze({
|
|
|
32099
32177
|
addonId: null,
|
|
32100
32178
|
access: "view"
|
|
32101
32179
|
},
|
|
32180
|
+
"pipelineAnalytics.getEventDensityBatch": {
|
|
32181
|
+
capName: "pipeline-analytics",
|
|
32182
|
+
capScope: "device",
|
|
32183
|
+
addonId: null,
|
|
32184
|
+
access: "view"
|
|
32185
|
+
},
|
|
32102
32186
|
"pipelineAnalytics.getEventMedia": {
|
|
32103
32187
|
capName: "pipeline-analytics",
|
|
32104
32188
|
capScope: "device",
|
|
@@ -33221,12 +33305,24 @@ Object.freeze({
|
|
|
33221
33305
|
addonId: null,
|
|
33222
33306
|
access: "view"
|
|
33223
33307
|
},
|
|
33308
|
+
"recording.getAvailabilityBatch": {
|
|
33309
|
+
capName: "recording",
|
|
33310
|
+
capScope: "system",
|
|
33311
|
+
addonId: null,
|
|
33312
|
+
access: "view"
|
|
33313
|
+
},
|
|
33224
33314
|
"recording.getDaysWithRecordings": {
|
|
33225
33315
|
capName: "recording",
|
|
33226
33316
|
capScope: "system",
|
|
33227
33317
|
addonId: null,
|
|
33228
33318
|
access: "view"
|
|
33229
33319
|
},
|
|
33320
|
+
"recording.getDaysWithRecordingsBatch": {
|
|
33321
|
+
capName: "recording",
|
|
33322
|
+
capScope: "system",
|
|
33323
|
+
addonId: null,
|
|
33324
|
+
access: "view"
|
|
33325
|
+
},
|
|
33230
33326
|
"recording.getDeviceConfig": {
|
|
33231
33327
|
capName: "recording",
|
|
33232
33328
|
capScope: "system",
|
|
@@ -35831,6 +35927,11 @@ Object.freeze({
|
|
|
35831
35927
|
form: "single",
|
|
35832
35928
|
optional: false
|
|
35833
35929
|
}],
|
|
35930
|
+
"pipelineAnalytics.getEventDensityBatch": [{
|
|
35931
|
+
name: "deviceIds",
|
|
35932
|
+
form: "array",
|
|
35933
|
+
optional: false
|
|
35934
|
+
}],
|
|
35834
35935
|
"pipelineAnalytics.getEventMedia": [{
|
|
35835
35936
|
name: "deviceId",
|
|
35836
35937
|
form: "single",
|
|
@@ -36246,11 +36347,21 @@ Object.freeze({
|
|
|
36246
36347
|
form: "single",
|
|
36247
36348
|
optional: false
|
|
36248
36349
|
}],
|
|
36350
|
+
"recording.getAvailabilityBatch": [{
|
|
36351
|
+
name: "deviceIds",
|
|
36352
|
+
form: "array",
|
|
36353
|
+
optional: false
|
|
36354
|
+
}],
|
|
36249
36355
|
"recording.getDaysWithRecordings": [{
|
|
36250
36356
|
name: "deviceId",
|
|
36251
36357
|
form: "single",
|
|
36252
36358
|
optional: false
|
|
36253
36359
|
}],
|
|
36360
|
+
"recording.getDaysWithRecordingsBatch": [{
|
|
36361
|
+
name: "deviceIds",
|
|
36362
|
+
form: "array",
|
|
36363
|
+
optional: false
|
|
36364
|
+
}],
|
|
36254
36365
|
"recording.getDeviceConfig": [{
|
|
36255
36366
|
name: "deviceId",
|
|
36256
36367
|
form: "single",
|
package/dist/addon.mjs
CHANGED
|
@@ -15734,6 +15734,8 @@ var NcSystemEventKindSchema = _enum([
|
|
|
15734
15734
|
"device-offline",
|
|
15735
15735
|
"device-disabled",
|
|
15736
15736
|
"device-enabled",
|
|
15737
|
+
"device-battery-low",
|
|
15738
|
+
"device-battery-normal",
|
|
15737
15739
|
"stream-online",
|
|
15738
15740
|
"stream-offline",
|
|
15739
15741
|
"node-online",
|
|
@@ -19008,6 +19010,34 @@ var KeyEventsForDeviceSchema = object({
|
|
|
19008
19010
|
deviceId: number(),
|
|
19009
19011
|
events: array(KeyEventSchema).readonly()
|
|
19010
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
|
+
});
|
|
19011
19041
|
object({
|
|
19012
19042
|
trackId: string(),
|
|
19013
19043
|
className: string(),
|
|
@@ -19318,12 +19348,12 @@ DeviceType.Camera, method(object({ deviceId: number() }), array(TrackSchema).rea
|
|
|
19318
19348
|
since: number(),
|
|
19319
19349
|
until: number(),
|
|
19320
19350
|
bucketMs: number().int().positive()
|
|
19321
|
-
}), array(object({
|
|
19322
|
-
|
|
19323
|
-
|
|
19324
|
-
|
|
19325
|
-
|
|
19326
|
-
})).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({
|
|
19327
19357
|
deviceId: number(),
|
|
19328
19358
|
cutoffMs: number()
|
|
19329
19359
|
}), object({
|
|
@@ -26633,6 +26663,39 @@ var RecordingDaysSchema = object({
|
|
|
26633
26663
|
/** Local-midnight epochs (UTC ms) of days that have ≥1 recorded segment. */
|
|
26634
26664
|
days: array(number())
|
|
26635
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
|
+
});
|
|
26636
26699
|
var RecordingManifestSchema = object({
|
|
26637
26700
|
deviceId: number(),
|
|
26638
26701
|
/** Local filesystem path to the master playlist; null when no recording exists for the requested range. */
|
|
@@ -26867,6 +26930,13 @@ method(object({
|
|
|
26867
26930
|
}), RecordingAvailabilitySchema, {
|
|
26868
26931
|
kind: "query",
|
|
26869
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"
|
|
26870
26940
|
}), method(object({
|
|
26871
26941
|
deviceId: number(),
|
|
26872
26942
|
fromMs: number(),
|
|
@@ -26875,6 +26945,14 @@ method(object({
|
|
|
26875
26945
|
}), RecordingDaysSchema, {
|
|
26876
26946
|
kind: "query",
|
|
26877
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"
|
|
26878
26956
|
}), method(object({
|
|
26879
26957
|
deviceId: number(),
|
|
26880
26958
|
fromMs: number(),
|
|
@@ -32072,6 +32150,12 @@ Object.freeze({
|
|
|
32072
32150
|
addonId: null,
|
|
32073
32151
|
access: "view"
|
|
32074
32152
|
},
|
|
32153
|
+
"pipelineAnalytics.getEventDensityBatch": {
|
|
32154
|
+
capName: "pipeline-analytics",
|
|
32155
|
+
capScope: "device",
|
|
32156
|
+
addonId: null,
|
|
32157
|
+
access: "view"
|
|
32158
|
+
},
|
|
32075
32159
|
"pipelineAnalytics.getEventMedia": {
|
|
32076
32160
|
capName: "pipeline-analytics",
|
|
32077
32161
|
capScope: "device",
|
|
@@ -33194,12 +33278,24 @@ Object.freeze({
|
|
|
33194
33278
|
addonId: null,
|
|
33195
33279
|
access: "view"
|
|
33196
33280
|
},
|
|
33281
|
+
"recording.getAvailabilityBatch": {
|
|
33282
|
+
capName: "recording",
|
|
33283
|
+
capScope: "system",
|
|
33284
|
+
addonId: null,
|
|
33285
|
+
access: "view"
|
|
33286
|
+
},
|
|
33197
33287
|
"recording.getDaysWithRecordings": {
|
|
33198
33288
|
capName: "recording",
|
|
33199
33289
|
capScope: "system",
|
|
33200
33290
|
addonId: null,
|
|
33201
33291
|
access: "view"
|
|
33202
33292
|
},
|
|
33293
|
+
"recording.getDaysWithRecordingsBatch": {
|
|
33294
|
+
capName: "recording",
|
|
33295
|
+
capScope: "system",
|
|
33296
|
+
addonId: null,
|
|
33297
|
+
access: "view"
|
|
33298
|
+
},
|
|
33203
33299
|
"recording.getDeviceConfig": {
|
|
33204
33300
|
capName: "recording",
|
|
33205
33301
|
capScope: "system",
|
|
@@ -35804,6 +35900,11 @@ Object.freeze({
|
|
|
35804
35900
|
form: "single",
|
|
35805
35901
|
optional: false
|
|
35806
35902
|
}],
|
|
35903
|
+
"pipelineAnalytics.getEventDensityBatch": [{
|
|
35904
|
+
name: "deviceIds",
|
|
35905
|
+
form: "array",
|
|
35906
|
+
optional: false
|
|
35907
|
+
}],
|
|
35807
35908
|
"pipelineAnalytics.getEventMedia": [{
|
|
35808
35909
|
name: "deviceId",
|
|
35809
35910
|
form: "single",
|
|
@@ -36219,11 +36320,21 @@ Object.freeze({
|
|
|
36219
36320
|
form: "single",
|
|
36220
36321
|
optional: false
|
|
36221
36322
|
}],
|
|
36323
|
+
"recording.getAvailabilityBatch": [{
|
|
36324
|
+
name: "deviceIds",
|
|
36325
|
+
form: "array",
|
|
36326
|
+
optional: false
|
|
36327
|
+
}],
|
|
36222
36328
|
"recording.getDaysWithRecordings": [{
|
|
36223
36329
|
name: "deviceId",
|
|
36224
36330
|
form: "single",
|
|
36225
36331
|
optional: false
|
|
36226
36332
|
}],
|
|
36333
|
+
"recording.getDaysWithRecordingsBatch": [{
|
|
36334
|
+
name: "deviceIds",
|
|
36335
|
+
form: "array",
|
|
36336
|
+
optional: false
|
|
36337
|
+
}],
|
|
36227
36338
|
"recording.getDeviceConfig": [{
|
|
36228
36339
|
name: "deviceId",
|
|
36229
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",
|