@camstack/addon-mqtt-broker 1.2.51 → 1.2.52
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/mqtt-broker.addon.js +115 -6
- package/dist/mqtt-broker.addon.mjs +115 -6
- package/package.json +1 -1
|
@@ -18946,6 +18946,34 @@ var KeyEventsForDeviceSchema = object({
|
|
|
18946
18946
|
deviceId: number(),
|
|
18947
18947
|
events: array(KeyEventSchema).readonly()
|
|
18948
18948
|
});
|
|
18949
|
+
/** One non-empty bucket of the timeline histogram. */
|
|
18950
|
+
var EventDensityBucketSchema = object({
|
|
18951
|
+
bucketStart: number(),
|
|
18952
|
+
motion: number().int(),
|
|
18953
|
+
object: number().int(),
|
|
18954
|
+
audio: number().int()
|
|
18955
|
+
});
|
|
18956
|
+
/**
|
|
18957
|
+
* One camera's row in a `getEventDensityBatch` answer.
|
|
18958
|
+
*
|
|
18959
|
+
* TWO facts, and the timeline draws them differently:
|
|
18960
|
+
*
|
|
18961
|
+
* - `read: 'read'` — the histogram for this camera. `buckets: []` is a real
|
|
18962
|
+
* claim: read, and nothing happened in the window.
|
|
18963
|
+
* - `read: 'unreadable'` — nobody could answer for this camera. `buckets` is
|
|
18964
|
+
* empty and that emptiness means NOTHING; the timeline must render unknown,
|
|
18965
|
+
* not quiet.
|
|
18966
|
+
*
|
|
18967
|
+
* Fanned out per camera the difference was free — one query rejected while the
|
|
18968
|
+
* others resolved — and collapsing to a batch is the exact moment it is lost
|
|
18969
|
+
* silently. Every requested id gets a row: a caller that asked for twelve and
|
|
18970
|
+
* got eleven cannot tell which one is missing, or that any is.
|
|
18971
|
+
*/
|
|
18972
|
+
var EventDensityForDeviceSchema = object({
|
|
18973
|
+
deviceId: number(),
|
|
18974
|
+
read: _enum(["read", "unreadable"]),
|
|
18975
|
+
buckets: array(EventDensityBucketSchema).readonly()
|
|
18976
|
+
});
|
|
18949
18977
|
object({
|
|
18950
18978
|
trackId: string(),
|
|
18951
18979
|
className: string(),
|
|
@@ -19256,12 +19284,12 @@ DeviceType.Camera, method(object({ deviceId: number() }), array(TrackSchema).rea
|
|
|
19256
19284
|
since: number(),
|
|
19257
19285
|
until: number(),
|
|
19258
19286
|
bucketMs: number().int().positive()
|
|
19259
|
-
}), array(object({
|
|
19260
|
-
|
|
19261
|
-
|
|
19262
|
-
|
|
19263
|
-
|
|
19264
|
-
})).readonly()), method(object({
|
|
19287
|
+
}), array(EventDensityBucketSchema).readonly()), method(object({
|
|
19288
|
+
deviceIds: array(number()).min(1).max(200),
|
|
19289
|
+
since: number(),
|
|
19290
|
+
until: number(),
|
|
19291
|
+
bucketMs: number().int().positive()
|
|
19292
|
+
}), array(EventDensityForDeviceSchema).readonly()), method(object({
|
|
19265
19293
|
deviceId: number(),
|
|
19266
19294
|
cutoffMs: number()
|
|
19267
19295
|
}), object({
|
|
@@ -26571,6 +26599,39 @@ var RecordingDaysSchema = object({
|
|
|
26571
26599
|
/** Local-midnight epochs (UTC ms) of days that have ≥1 recorded segment. */
|
|
26572
26600
|
days: array(number())
|
|
26573
26601
|
});
|
|
26602
|
+
/**
|
|
26603
|
+
* One camera's row in a `getAvailabilityBatch` answer.
|
|
26604
|
+
*
|
|
26605
|
+
* `ranges` is EXACTLY what `getAvailability` returns for that camera — the
|
|
26606
|
+
* batch collapses the transport, not the work — plus the one thing the singular
|
|
26607
|
+
* method never had to say:
|
|
26608
|
+
*
|
|
26609
|
+
* - `read: 'read'` — answered. `ranges: []` means "read, and this camera has
|
|
26610
|
+
* no footage in the window", which is a real claim.
|
|
26611
|
+
* - `read: 'unreadable'` — the recorder could not answer for this camera (its
|
|
26612
|
+
* calendar rung threw, its location is unmounted). `ranges` is empty and
|
|
26613
|
+
* that emptiness means NOTHING.
|
|
26614
|
+
*
|
|
26615
|
+
* A timeline that renders the second as the first tells an operator there is no
|
|
26616
|
+
* footage when the truth is that nobody looked.
|
|
26617
|
+
*/
|
|
26618
|
+
var RecordingAvailabilityForDeviceSchema = object({
|
|
26619
|
+
deviceId: number(),
|
|
26620
|
+
read: _enum(["read", "unreadable"]),
|
|
26621
|
+
ranges: array(RecordingRangeSchema).readonly()
|
|
26622
|
+
});
|
|
26623
|
+
/**
|
|
26624
|
+
* One camera's row in a `getDaysWithRecordingsBatch` answer. Same rule as
|
|
26625
|
+
* {@link RecordingAvailabilityForDeviceSchema}: `days: []` on a `'read'` row is
|
|
26626
|
+
* "no footage in this month", `read: 'unreadable'` is "nobody could look", and
|
|
26627
|
+
* the date-picker's day dots must not spell them the same.
|
|
26628
|
+
*/
|
|
26629
|
+
var RecordingDaysForDeviceSchema = object({
|
|
26630
|
+
deviceId: number(),
|
|
26631
|
+
read: _enum(["read", "unreadable"]),
|
|
26632
|
+
/** Local-midnight epochs (UTC ms) of days that have ≥1 recorded segment. */
|
|
26633
|
+
days: array(number()).readonly()
|
|
26634
|
+
});
|
|
26574
26635
|
var RecordingManifestSchema = object({
|
|
26575
26636
|
deviceId: number(),
|
|
26576
26637
|
/** Local filesystem path to the master playlist; null when no recording exists for the requested range. */
|
|
@@ -26805,6 +26866,13 @@ method(object({
|
|
|
26805
26866
|
}), RecordingAvailabilitySchema, {
|
|
26806
26867
|
kind: "query",
|
|
26807
26868
|
auth: "protected"
|
|
26869
|
+
}), method(object({
|
|
26870
|
+
deviceIds: array(number()).min(1).max(200),
|
|
26871
|
+
fromMs: number(),
|
|
26872
|
+
toMs: number()
|
|
26873
|
+
}), array(RecordingAvailabilityForDeviceSchema).readonly(), {
|
|
26874
|
+
kind: "query",
|
|
26875
|
+
auth: "protected"
|
|
26808
26876
|
}), method(object({
|
|
26809
26877
|
deviceId: number(),
|
|
26810
26878
|
fromMs: number(),
|
|
@@ -26813,6 +26881,14 @@ method(object({
|
|
|
26813
26881
|
}), RecordingDaysSchema, {
|
|
26814
26882
|
kind: "query",
|
|
26815
26883
|
auth: "protected"
|
|
26884
|
+
}), method(object({
|
|
26885
|
+
deviceIds: array(number()).min(1).max(200),
|
|
26886
|
+
fromMs: number(),
|
|
26887
|
+
toMs: number(),
|
|
26888
|
+
tzOffsetMinutes: number()
|
|
26889
|
+
}), array(RecordingDaysForDeviceSchema).readonly(), {
|
|
26890
|
+
kind: "query",
|
|
26891
|
+
auth: "protected"
|
|
26816
26892
|
}), method(object({
|
|
26817
26893
|
deviceId: number(),
|
|
26818
26894
|
fromMs: number(),
|
|
@@ -32010,6 +32086,12 @@ Object.freeze({
|
|
|
32010
32086
|
addonId: null,
|
|
32011
32087
|
access: "view"
|
|
32012
32088
|
},
|
|
32089
|
+
"pipelineAnalytics.getEventDensityBatch": {
|
|
32090
|
+
capName: "pipeline-analytics",
|
|
32091
|
+
capScope: "device",
|
|
32092
|
+
addonId: null,
|
|
32093
|
+
access: "view"
|
|
32094
|
+
},
|
|
32013
32095
|
"pipelineAnalytics.getEventMedia": {
|
|
32014
32096
|
capName: "pipeline-analytics",
|
|
32015
32097
|
capScope: "device",
|
|
@@ -33132,12 +33214,24 @@ Object.freeze({
|
|
|
33132
33214
|
addonId: null,
|
|
33133
33215
|
access: "view"
|
|
33134
33216
|
},
|
|
33217
|
+
"recording.getAvailabilityBatch": {
|
|
33218
|
+
capName: "recording",
|
|
33219
|
+
capScope: "system",
|
|
33220
|
+
addonId: null,
|
|
33221
|
+
access: "view"
|
|
33222
|
+
},
|
|
33135
33223
|
"recording.getDaysWithRecordings": {
|
|
33136
33224
|
capName: "recording",
|
|
33137
33225
|
capScope: "system",
|
|
33138
33226
|
addonId: null,
|
|
33139
33227
|
access: "view"
|
|
33140
33228
|
},
|
|
33229
|
+
"recording.getDaysWithRecordingsBatch": {
|
|
33230
|
+
capName: "recording",
|
|
33231
|
+
capScope: "system",
|
|
33232
|
+
addonId: null,
|
|
33233
|
+
access: "view"
|
|
33234
|
+
},
|
|
33141
33235
|
"recording.getDeviceConfig": {
|
|
33142
33236
|
capName: "recording",
|
|
33143
33237
|
capScope: "system",
|
|
@@ -35742,6 +35836,11 @@ Object.freeze({
|
|
|
35742
35836
|
form: "single",
|
|
35743
35837
|
optional: false
|
|
35744
35838
|
}],
|
|
35839
|
+
"pipelineAnalytics.getEventDensityBatch": [{
|
|
35840
|
+
name: "deviceIds",
|
|
35841
|
+
form: "array",
|
|
35842
|
+
optional: false
|
|
35843
|
+
}],
|
|
35745
35844
|
"pipelineAnalytics.getEventMedia": [{
|
|
35746
35845
|
name: "deviceId",
|
|
35747
35846
|
form: "single",
|
|
@@ -36157,11 +36256,21 @@ Object.freeze({
|
|
|
36157
36256
|
form: "single",
|
|
36158
36257
|
optional: false
|
|
36159
36258
|
}],
|
|
36259
|
+
"recording.getAvailabilityBatch": [{
|
|
36260
|
+
name: "deviceIds",
|
|
36261
|
+
form: "array",
|
|
36262
|
+
optional: false
|
|
36263
|
+
}],
|
|
36160
36264
|
"recording.getDaysWithRecordings": [{
|
|
36161
36265
|
name: "deviceId",
|
|
36162
36266
|
form: "single",
|
|
36163
36267
|
optional: false
|
|
36164
36268
|
}],
|
|
36269
|
+
"recording.getDaysWithRecordingsBatch": [{
|
|
36270
|
+
name: "deviceIds",
|
|
36271
|
+
form: "array",
|
|
36272
|
+
optional: false
|
|
36273
|
+
}],
|
|
36165
36274
|
"recording.getDeviceConfig": [{
|
|
36166
36275
|
name: "deviceId",
|
|
36167
36276
|
form: "single",
|
|
@@ -18941,6 +18941,34 @@ var KeyEventsForDeviceSchema = object({
|
|
|
18941
18941
|
deviceId: number(),
|
|
18942
18942
|
events: array(KeyEventSchema).readonly()
|
|
18943
18943
|
});
|
|
18944
|
+
/** One non-empty bucket of the timeline histogram. */
|
|
18945
|
+
var EventDensityBucketSchema = object({
|
|
18946
|
+
bucketStart: number(),
|
|
18947
|
+
motion: number().int(),
|
|
18948
|
+
object: number().int(),
|
|
18949
|
+
audio: number().int()
|
|
18950
|
+
});
|
|
18951
|
+
/**
|
|
18952
|
+
* One camera's row in a `getEventDensityBatch` answer.
|
|
18953
|
+
*
|
|
18954
|
+
* TWO facts, and the timeline draws them differently:
|
|
18955
|
+
*
|
|
18956
|
+
* - `read: 'read'` — the histogram for this camera. `buckets: []` is a real
|
|
18957
|
+
* claim: read, and nothing happened in the window.
|
|
18958
|
+
* - `read: 'unreadable'` — nobody could answer for this camera. `buckets` is
|
|
18959
|
+
* empty and that emptiness means NOTHING; the timeline must render unknown,
|
|
18960
|
+
* not quiet.
|
|
18961
|
+
*
|
|
18962
|
+
* Fanned out per camera the difference was free — one query rejected while the
|
|
18963
|
+
* others resolved — and collapsing to a batch is the exact moment it is lost
|
|
18964
|
+
* silently. Every requested id gets a row: a caller that asked for twelve and
|
|
18965
|
+
* got eleven cannot tell which one is missing, or that any is.
|
|
18966
|
+
*/
|
|
18967
|
+
var EventDensityForDeviceSchema = object({
|
|
18968
|
+
deviceId: number(),
|
|
18969
|
+
read: _enum(["read", "unreadable"]),
|
|
18970
|
+
buckets: array(EventDensityBucketSchema).readonly()
|
|
18971
|
+
});
|
|
18944
18972
|
object({
|
|
18945
18973
|
trackId: string(),
|
|
18946
18974
|
className: string(),
|
|
@@ -19251,12 +19279,12 @@ DeviceType.Camera, method(object({ deviceId: number() }), array(TrackSchema).rea
|
|
|
19251
19279
|
since: number(),
|
|
19252
19280
|
until: number(),
|
|
19253
19281
|
bucketMs: number().int().positive()
|
|
19254
|
-
}), array(object({
|
|
19255
|
-
|
|
19256
|
-
|
|
19257
|
-
|
|
19258
|
-
|
|
19259
|
-
})).readonly()), method(object({
|
|
19282
|
+
}), array(EventDensityBucketSchema).readonly()), method(object({
|
|
19283
|
+
deviceIds: array(number()).min(1).max(200),
|
|
19284
|
+
since: number(),
|
|
19285
|
+
until: number(),
|
|
19286
|
+
bucketMs: number().int().positive()
|
|
19287
|
+
}), array(EventDensityForDeviceSchema).readonly()), method(object({
|
|
19260
19288
|
deviceId: number(),
|
|
19261
19289
|
cutoffMs: number()
|
|
19262
19290
|
}), object({
|
|
@@ -26566,6 +26594,39 @@ var RecordingDaysSchema = object({
|
|
|
26566
26594
|
/** Local-midnight epochs (UTC ms) of days that have ≥1 recorded segment. */
|
|
26567
26595
|
days: array(number())
|
|
26568
26596
|
});
|
|
26597
|
+
/**
|
|
26598
|
+
* One camera's row in a `getAvailabilityBatch` answer.
|
|
26599
|
+
*
|
|
26600
|
+
* `ranges` is EXACTLY what `getAvailability` returns for that camera — the
|
|
26601
|
+
* batch collapses the transport, not the work — plus the one thing the singular
|
|
26602
|
+
* method never had to say:
|
|
26603
|
+
*
|
|
26604
|
+
* - `read: 'read'` — answered. `ranges: []` means "read, and this camera has
|
|
26605
|
+
* no footage in the window", which is a real claim.
|
|
26606
|
+
* - `read: 'unreadable'` — the recorder could not answer for this camera (its
|
|
26607
|
+
* calendar rung threw, its location is unmounted). `ranges` is empty and
|
|
26608
|
+
* that emptiness means NOTHING.
|
|
26609
|
+
*
|
|
26610
|
+
* A timeline that renders the second as the first tells an operator there is no
|
|
26611
|
+
* footage when the truth is that nobody looked.
|
|
26612
|
+
*/
|
|
26613
|
+
var RecordingAvailabilityForDeviceSchema = object({
|
|
26614
|
+
deviceId: number(),
|
|
26615
|
+
read: _enum(["read", "unreadable"]),
|
|
26616
|
+
ranges: array(RecordingRangeSchema).readonly()
|
|
26617
|
+
});
|
|
26618
|
+
/**
|
|
26619
|
+
* One camera's row in a `getDaysWithRecordingsBatch` answer. Same rule as
|
|
26620
|
+
* {@link RecordingAvailabilityForDeviceSchema}: `days: []` on a `'read'` row is
|
|
26621
|
+
* "no footage in this month", `read: 'unreadable'` is "nobody could look", and
|
|
26622
|
+
* the date-picker's day dots must not spell them the same.
|
|
26623
|
+
*/
|
|
26624
|
+
var RecordingDaysForDeviceSchema = object({
|
|
26625
|
+
deviceId: number(),
|
|
26626
|
+
read: _enum(["read", "unreadable"]),
|
|
26627
|
+
/** Local-midnight epochs (UTC ms) of days that have ≥1 recorded segment. */
|
|
26628
|
+
days: array(number()).readonly()
|
|
26629
|
+
});
|
|
26569
26630
|
var RecordingManifestSchema = object({
|
|
26570
26631
|
deviceId: number(),
|
|
26571
26632
|
/** Local filesystem path to the master playlist; null when no recording exists for the requested range. */
|
|
@@ -26800,6 +26861,13 @@ method(object({
|
|
|
26800
26861
|
}), RecordingAvailabilitySchema, {
|
|
26801
26862
|
kind: "query",
|
|
26802
26863
|
auth: "protected"
|
|
26864
|
+
}), method(object({
|
|
26865
|
+
deviceIds: array(number()).min(1).max(200),
|
|
26866
|
+
fromMs: number(),
|
|
26867
|
+
toMs: number()
|
|
26868
|
+
}), array(RecordingAvailabilityForDeviceSchema).readonly(), {
|
|
26869
|
+
kind: "query",
|
|
26870
|
+
auth: "protected"
|
|
26803
26871
|
}), method(object({
|
|
26804
26872
|
deviceId: number(),
|
|
26805
26873
|
fromMs: number(),
|
|
@@ -26808,6 +26876,14 @@ method(object({
|
|
|
26808
26876
|
}), RecordingDaysSchema, {
|
|
26809
26877
|
kind: "query",
|
|
26810
26878
|
auth: "protected"
|
|
26879
|
+
}), method(object({
|
|
26880
|
+
deviceIds: array(number()).min(1).max(200),
|
|
26881
|
+
fromMs: number(),
|
|
26882
|
+
toMs: number(),
|
|
26883
|
+
tzOffsetMinutes: number()
|
|
26884
|
+
}), array(RecordingDaysForDeviceSchema).readonly(), {
|
|
26885
|
+
kind: "query",
|
|
26886
|
+
auth: "protected"
|
|
26811
26887
|
}), method(object({
|
|
26812
26888
|
deviceId: number(),
|
|
26813
26889
|
fromMs: number(),
|
|
@@ -32005,6 +32081,12 @@ Object.freeze({
|
|
|
32005
32081
|
addonId: null,
|
|
32006
32082
|
access: "view"
|
|
32007
32083
|
},
|
|
32084
|
+
"pipelineAnalytics.getEventDensityBatch": {
|
|
32085
|
+
capName: "pipeline-analytics",
|
|
32086
|
+
capScope: "device",
|
|
32087
|
+
addonId: null,
|
|
32088
|
+
access: "view"
|
|
32089
|
+
},
|
|
32008
32090
|
"pipelineAnalytics.getEventMedia": {
|
|
32009
32091
|
capName: "pipeline-analytics",
|
|
32010
32092
|
capScope: "device",
|
|
@@ -33127,12 +33209,24 @@ Object.freeze({
|
|
|
33127
33209
|
addonId: null,
|
|
33128
33210
|
access: "view"
|
|
33129
33211
|
},
|
|
33212
|
+
"recording.getAvailabilityBatch": {
|
|
33213
|
+
capName: "recording",
|
|
33214
|
+
capScope: "system",
|
|
33215
|
+
addonId: null,
|
|
33216
|
+
access: "view"
|
|
33217
|
+
},
|
|
33130
33218
|
"recording.getDaysWithRecordings": {
|
|
33131
33219
|
capName: "recording",
|
|
33132
33220
|
capScope: "system",
|
|
33133
33221
|
addonId: null,
|
|
33134
33222
|
access: "view"
|
|
33135
33223
|
},
|
|
33224
|
+
"recording.getDaysWithRecordingsBatch": {
|
|
33225
|
+
capName: "recording",
|
|
33226
|
+
capScope: "system",
|
|
33227
|
+
addonId: null,
|
|
33228
|
+
access: "view"
|
|
33229
|
+
},
|
|
33136
33230
|
"recording.getDeviceConfig": {
|
|
33137
33231
|
capName: "recording",
|
|
33138
33232
|
capScope: "system",
|
|
@@ -35737,6 +35831,11 @@ Object.freeze({
|
|
|
35737
35831
|
form: "single",
|
|
35738
35832
|
optional: false
|
|
35739
35833
|
}],
|
|
35834
|
+
"pipelineAnalytics.getEventDensityBatch": [{
|
|
35835
|
+
name: "deviceIds",
|
|
35836
|
+
form: "array",
|
|
35837
|
+
optional: false
|
|
35838
|
+
}],
|
|
35740
35839
|
"pipelineAnalytics.getEventMedia": [{
|
|
35741
35840
|
name: "deviceId",
|
|
35742
35841
|
form: "single",
|
|
@@ -36152,11 +36251,21 @@ Object.freeze({
|
|
|
36152
36251
|
form: "single",
|
|
36153
36252
|
optional: false
|
|
36154
36253
|
}],
|
|
36254
|
+
"recording.getAvailabilityBatch": [{
|
|
36255
|
+
name: "deviceIds",
|
|
36256
|
+
form: "array",
|
|
36257
|
+
optional: false
|
|
36258
|
+
}],
|
|
36155
36259
|
"recording.getDaysWithRecordings": [{
|
|
36156
36260
|
name: "deviceId",
|
|
36157
36261
|
form: "single",
|
|
36158
36262
|
optional: false
|
|
36159
36263
|
}],
|
|
36264
|
+
"recording.getDaysWithRecordingsBatch": [{
|
|
36265
|
+
name: "deviceIds",
|
|
36266
|
+
form: "array",
|
|
36267
|
+
optional: false
|
|
36268
|
+
}],
|
|
36160
36269
|
"recording.getDeviceConfig": [{
|
|
36161
36270
|
name: "deviceId",
|
|
36162
36271
|
form: "single",
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@camstack/addon-mqtt-broker",
|
|
3
|
-
"version": "1.2.
|
|
3
|
+
"version": "1.2.52",
|
|
4
4
|
"description": "MQTT broker registry addon for CamStack — manages external broker entries + an optional embedded aedes broker. Consumers spin up their own `mqtt.js` clients via the `mqtt-broker` cap.",
|
|
5
5
|
"keywords": [
|
|
6
6
|
"camstack",
|