@camstack/addon-decoder-nodeav 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/index.js CHANGED
@@ -18979,6 +18979,34 @@ var KeyEventsForDeviceSchema = object({
18979
18979
  deviceId: number(),
18980
18980
  events: array(KeyEventSchema).readonly()
18981
18981
  });
18982
+ /** One non-empty bucket of the timeline histogram. */
18983
+ var EventDensityBucketSchema = object({
18984
+ bucketStart: number(),
18985
+ motion: number().int(),
18986
+ object: number().int(),
18987
+ audio: number().int()
18988
+ });
18989
+ /**
18990
+ * One camera's row in a `getEventDensityBatch` answer.
18991
+ *
18992
+ * TWO facts, and the timeline draws them differently:
18993
+ *
18994
+ * - `read: 'read'` — the histogram for this camera. `buckets: []` is a real
18995
+ * claim: read, and nothing happened in the window.
18996
+ * - `read: 'unreadable'` — nobody could answer for this camera. `buckets` is
18997
+ * empty and that emptiness means NOTHING; the timeline must render unknown,
18998
+ * not quiet.
18999
+ *
19000
+ * Fanned out per camera the difference was free — one query rejected while the
19001
+ * others resolved — and collapsing to a batch is the exact moment it is lost
19002
+ * silently. Every requested id gets a row: a caller that asked for twelve and
19003
+ * got eleven cannot tell which one is missing, or that any is.
19004
+ */
19005
+ var EventDensityForDeviceSchema = object({
19006
+ deviceId: number(),
19007
+ read: _enum(["read", "unreadable"]),
19008
+ buckets: array(EventDensityBucketSchema).readonly()
19009
+ });
18982
19010
  object({
18983
19011
  trackId: string(),
18984
19012
  className: string(),
@@ -19289,12 +19317,12 @@ DeviceType.Camera, method(object({ deviceId: number() }), array(TrackSchema).rea
19289
19317
  since: number(),
19290
19318
  until: number(),
19291
19319
  bucketMs: number().int().positive()
19292
- }), array(object({
19293
- bucketStart: number(),
19294
- motion: number().int(),
19295
- object: number().int(),
19296
- audio: number().int()
19297
- })).readonly()), method(object({
19320
+ }), array(EventDensityBucketSchema).readonly()), method(object({
19321
+ deviceIds: array(number()).min(1).max(200),
19322
+ since: number(),
19323
+ until: number(),
19324
+ bucketMs: number().int().positive()
19325
+ }), array(EventDensityForDeviceSchema).readonly()), method(object({
19298
19326
  deviceId: number(),
19299
19327
  cutoffMs: number()
19300
19328
  }), object({
@@ -26604,6 +26632,39 @@ var RecordingDaysSchema = object({
26604
26632
  /** Local-midnight epochs (UTC ms) of days that have ≥1 recorded segment. */
26605
26633
  days: array(number())
26606
26634
  });
26635
+ /**
26636
+ * One camera's row in a `getAvailabilityBatch` answer.
26637
+ *
26638
+ * `ranges` is EXACTLY what `getAvailability` returns for that camera — the
26639
+ * batch collapses the transport, not the work — plus the one thing the singular
26640
+ * method never had to say:
26641
+ *
26642
+ * - `read: 'read'` — answered. `ranges: []` means "read, and this camera has
26643
+ * no footage in the window", which is a real claim.
26644
+ * - `read: 'unreadable'` — the recorder could not answer for this camera (its
26645
+ * calendar rung threw, its location is unmounted). `ranges` is empty and
26646
+ * that emptiness means NOTHING.
26647
+ *
26648
+ * A timeline that renders the second as the first tells an operator there is no
26649
+ * footage when the truth is that nobody looked.
26650
+ */
26651
+ var RecordingAvailabilityForDeviceSchema = object({
26652
+ deviceId: number(),
26653
+ read: _enum(["read", "unreadable"]),
26654
+ ranges: array(RecordingRangeSchema).readonly()
26655
+ });
26656
+ /**
26657
+ * One camera's row in a `getDaysWithRecordingsBatch` answer. Same rule as
26658
+ * {@link RecordingAvailabilityForDeviceSchema}: `days: []` on a `'read'` row is
26659
+ * "no footage in this month", `read: 'unreadable'` is "nobody could look", and
26660
+ * the date-picker's day dots must not spell them the same.
26661
+ */
26662
+ var RecordingDaysForDeviceSchema = object({
26663
+ deviceId: number(),
26664
+ read: _enum(["read", "unreadable"]),
26665
+ /** Local-midnight epochs (UTC ms) of days that have ≥1 recorded segment. */
26666
+ days: array(number()).readonly()
26667
+ });
26607
26668
  var RecordingManifestSchema = object({
26608
26669
  deviceId: number(),
26609
26670
  /** Local filesystem path to the master playlist; null when no recording exists for the requested range. */
@@ -26838,6 +26899,13 @@ method(object({
26838
26899
  }), RecordingAvailabilitySchema, {
26839
26900
  kind: "query",
26840
26901
  auth: "protected"
26902
+ }), method(object({
26903
+ deviceIds: array(number()).min(1).max(200),
26904
+ fromMs: number(),
26905
+ toMs: number()
26906
+ }), array(RecordingAvailabilityForDeviceSchema).readonly(), {
26907
+ kind: "query",
26908
+ auth: "protected"
26841
26909
  }), method(object({
26842
26910
  deviceId: number(),
26843
26911
  fromMs: number(),
@@ -26846,6 +26914,14 @@ method(object({
26846
26914
  }), RecordingDaysSchema, {
26847
26915
  kind: "query",
26848
26916
  auth: "protected"
26917
+ }), method(object({
26918
+ deviceIds: array(number()).min(1).max(200),
26919
+ fromMs: number(),
26920
+ toMs: number(),
26921
+ tzOffsetMinutes: number()
26922
+ }), array(RecordingDaysForDeviceSchema).readonly(), {
26923
+ kind: "query",
26924
+ auth: "protected"
26849
26925
  }), method(object({
26850
26926
  deviceId: number(),
26851
26927
  fromMs: number(),
@@ -32043,6 +32119,12 @@ Object.freeze({
32043
32119
  addonId: null,
32044
32120
  access: "view"
32045
32121
  },
32122
+ "pipelineAnalytics.getEventDensityBatch": {
32123
+ capName: "pipeline-analytics",
32124
+ capScope: "device",
32125
+ addonId: null,
32126
+ access: "view"
32127
+ },
32046
32128
  "pipelineAnalytics.getEventMedia": {
32047
32129
  capName: "pipeline-analytics",
32048
32130
  capScope: "device",
@@ -33165,12 +33247,24 @@ Object.freeze({
33165
33247
  addonId: null,
33166
33248
  access: "view"
33167
33249
  },
33250
+ "recording.getAvailabilityBatch": {
33251
+ capName: "recording",
33252
+ capScope: "system",
33253
+ addonId: null,
33254
+ access: "view"
33255
+ },
33168
33256
  "recording.getDaysWithRecordings": {
33169
33257
  capName: "recording",
33170
33258
  capScope: "system",
33171
33259
  addonId: null,
33172
33260
  access: "view"
33173
33261
  },
33262
+ "recording.getDaysWithRecordingsBatch": {
33263
+ capName: "recording",
33264
+ capScope: "system",
33265
+ addonId: null,
33266
+ access: "view"
33267
+ },
33174
33268
  "recording.getDeviceConfig": {
33175
33269
  capName: "recording",
33176
33270
  capScope: "system",
@@ -35775,6 +35869,11 @@ Object.freeze({
35775
35869
  form: "single",
35776
35870
  optional: false
35777
35871
  }],
35872
+ "pipelineAnalytics.getEventDensityBatch": [{
35873
+ name: "deviceIds",
35874
+ form: "array",
35875
+ optional: false
35876
+ }],
35778
35877
  "pipelineAnalytics.getEventMedia": [{
35779
35878
  name: "deviceId",
35780
35879
  form: "single",
@@ -36190,11 +36289,21 @@ Object.freeze({
36190
36289
  form: "single",
36191
36290
  optional: false
36192
36291
  }],
36292
+ "recording.getAvailabilityBatch": [{
36293
+ name: "deviceIds",
36294
+ form: "array",
36295
+ optional: false
36296
+ }],
36193
36297
  "recording.getDaysWithRecordings": [{
36194
36298
  name: "deviceId",
36195
36299
  form: "single",
36196
36300
  optional: false
36197
36301
  }],
36302
+ "recording.getDaysWithRecordingsBatch": [{
36303
+ name: "deviceIds",
36304
+ form: "array",
36305
+ optional: false
36306
+ }],
36198
36307
  "recording.getDeviceConfig": [{
36199
36308
  name: "deviceId",
36200
36309
  form: "single",
package/dist/index.mjs CHANGED
@@ -18975,6 +18975,34 @@ var KeyEventsForDeviceSchema = object({
18975
18975
  deviceId: number(),
18976
18976
  events: array(KeyEventSchema).readonly()
18977
18977
  });
18978
+ /** One non-empty bucket of the timeline histogram. */
18979
+ var EventDensityBucketSchema = object({
18980
+ bucketStart: number(),
18981
+ motion: number().int(),
18982
+ object: number().int(),
18983
+ audio: number().int()
18984
+ });
18985
+ /**
18986
+ * One camera's row in a `getEventDensityBatch` answer.
18987
+ *
18988
+ * TWO facts, and the timeline draws them differently:
18989
+ *
18990
+ * - `read: 'read'` — the histogram for this camera. `buckets: []` is a real
18991
+ * claim: read, and nothing happened in the window.
18992
+ * - `read: 'unreadable'` — nobody could answer for this camera. `buckets` is
18993
+ * empty and that emptiness means NOTHING; the timeline must render unknown,
18994
+ * not quiet.
18995
+ *
18996
+ * Fanned out per camera the difference was free — one query rejected while the
18997
+ * others resolved — and collapsing to a batch is the exact moment it is lost
18998
+ * silently. Every requested id gets a row: a caller that asked for twelve and
18999
+ * got eleven cannot tell which one is missing, or that any is.
19000
+ */
19001
+ var EventDensityForDeviceSchema = object({
19002
+ deviceId: number(),
19003
+ read: _enum(["read", "unreadable"]),
19004
+ buckets: array(EventDensityBucketSchema).readonly()
19005
+ });
18978
19006
  object({
18979
19007
  trackId: string(),
18980
19008
  className: string(),
@@ -19285,12 +19313,12 @@ DeviceType.Camera, method(object({ deviceId: number() }), array(TrackSchema).rea
19285
19313
  since: number(),
19286
19314
  until: number(),
19287
19315
  bucketMs: number().int().positive()
19288
- }), array(object({
19289
- bucketStart: number(),
19290
- motion: number().int(),
19291
- object: number().int(),
19292
- audio: number().int()
19293
- })).readonly()), method(object({
19316
+ }), array(EventDensityBucketSchema).readonly()), method(object({
19317
+ deviceIds: array(number()).min(1).max(200),
19318
+ since: number(),
19319
+ until: number(),
19320
+ bucketMs: number().int().positive()
19321
+ }), array(EventDensityForDeviceSchema).readonly()), method(object({
19294
19322
  deviceId: number(),
19295
19323
  cutoffMs: number()
19296
19324
  }), object({
@@ -26600,6 +26628,39 @@ var RecordingDaysSchema = object({
26600
26628
  /** Local-midnight epochs (UTC ms) of days that have ≥1 recorded segment. */
26601
26629
  days: array(number())
26602
26630
  });
26631
+ /**
26632
+ * One camera's row in a `getAvailabilityBatch` answer.
26633
+ *
26634
+ * `ranges` is EXACTLY what `getAvailability` returns for that camera — the
26635
+ * batch collapses the transport, not the work — plus the one thing the singular
26636
+ * method never had to say:
26637
+ *
26638
+ * - `read: 'read'` — answered. `ranges: []` means "read, and this camera has
26639
+ * no footage in the window", which is a real claim.
26640
+ * - `read: 'unreadable'` — the recorder could not answer for this camera (its
26641
+ * calendar rung threw, its location is unmounted). `ranges` is empty and
26642
+ * that emptiness means NOTHING.
26643
+ *
26644
+ * A timeline that renders the second as the first tells an operator there is no
26645
+ * footage when the truth is that nobody looked.
26646
+ */
26647
+ var RecordingAvailabilityForDeviceSchema = object({
26648
+ deviceId: number(),
26649
+ read: _enum(["read", "unreadable"]),
26650
+ ranges: array(RecordingRangeSchema).readonly()
26651
+ });
26652
+ /**
26653
+ * One camera's row in a `getDaysWithRecordingsBatch` answer. Same rule as
26654
+ * {@link RecordingAvailabilityForDeviceSchema}: `days: []` on a `'read'` row is
26655
+ * "no footage in this month", `read: 'unreadable'` is "nobody could look", and
26656
+ * the date-picker's day dots must not spell them the same.
26657
+ */
26658
+ var RecordingDaysForDeviceSchema = object({
26659
+ deviceId: number(),
26660
+ read: _enum(["read", "unreadable"]),
26661
+ /** Local-midnight epochs (UTC ms) of days that have ≥1 recorded segment. */
26662
+ days: array(number()).readonly()
26663
+ });
26603
26664
  var RecordingManifestSchema = object({
26604
26665
  deviceId: number(),
26605
26666
  /** Local filesystem path to the master playlist; null when no recording exists for the requested range. */
@@ -26834,6 +26895,13 @@ method(object({
26834
26895
  }), RecordingAvailabilitySchema, {
26835
26896
  kind: "query",
26836
26897
  auth: "protected"
26898
+ }), method(object({
26899
+ deviceIds: array(number()).min(1).max(200),
26900
+ fromMs: number(),
26901
+ toMs: number()
26902
+ }), array(RecordingAvailabilityForDeviceSchema).readonly(), {
26903
+ kind: "query",
26904
+ auth: "protected"
26837
26905
  }), method(object({
26838
26906
  deviceId: number(),
26839
26907
  fromMs: number(),
@@ -26842,6 +26910,14 @@ method(object({
26842
26910
  }), RecordingDaysSchema, {
26843
26911
  kind: "query",
26844
26912
  auth: "protected"
26913
+ }), method(object({
26914
+ deviceIds: array(number()).min(1).max(200),
26915
+ fromMs: number(),
26916
+ toMs: number(),
26917
+ tzOffsetMinutes: number()
26918
+ }), array(RecordingDaysForDeviceSchema).readonly(), {
26919
+ kind: "query",
26920
+ auth: "protected"
26845
26921
  }), method(object({
26846
26922
  deviceId: number(),
26847
26923
  fromMs: number(),
@@ -32039,6 +32115,12 @@ Object.freeze({
32039
32115
  addonId: null,
32040
32116
  access: "view"
32041
32117
  },
32118
+ "pipelineAnalytics.getEventDensityBatch": {
32119
+ capName: "pipeline-analytics",
32120
+ capScope: "device",
32121
+ addonId: null,
32122
+ access: "view"
32123
+ },
32042
32124
  "pipelineAnalytics.getEventMedia": {
32043
32125
  capName: "pipeline-analytics",
32044
32126
  capScope: "device",
@@ -33161,12 +33243,24 @@ Object.freeze({
33161
33243
  addonId: null,
33162
33244
  access: "view"
33163
33245
  },
33246
+ "recording.getAvailabilityBatch": {
33247
+ capName: "recording",
33248
+ capScope: "system",
33249
+ addonId: null,
33250
+ access: "view"
33251
+ },
33164
33252
  "recording.getDaysWithRecordings": {
33165
33253
  capName: "recording",
33166
33254
  capScope: "system",
33167
33255
  addonId: null,
33168
33256
  access: "view"
33169
33257
  },
33258
+ "recording.getDaysWithRecordingsBatch": {
33259
+ capName: "recording",
33260
+ capScope: "system",
33261
+ addonId: null,
33262
+ access: "view"
33263
+ },
33170
33264
  "recording.getDeviceConfig": {
33171
33265
  capName: "recording",
33172
33266
  capScope: "system",
@@ -35771,6 +35865,11 @@ Object.freeze({
35771
35865
  form: "single",
35772
35866
  optional: false
35773
35867
  }],
35868
+ "pipelineAnalytics.getEventDensityBatch": [{
35869
+ name: "deviceIds",
35870
+ form: "array",
35871
+ optional: false
35872
+ }],
35774
35873
  "pipelineAnalytics.getEventMedia": [{
35775
35874
  name: "deviceId",
35776
35875
  form: "single",
@@ -36186,11 +36285,21 @@ Object.freeze({
36186
36285
  form: "single",
36187
36286
  optional: false
36188
36287
  }],
36288
+ "recording.getAvailabilityBatch": [{
36289
+ name: "deviceIds",
36290
+ form: "array",
36291
+ optional: false
36292
+ }],
36189
36293
  "recording.getDaysWithRecordings": [{
36190
36294
  name: "deviceId",
36191
36295
  form: "single",
36192
36296
  optional: false
36193
36297
  }],
36298
+ "recording.getDaysWithRecordingsBatch": [{
36299
+ name: "deviceIds",
36300
+ form: "array",
36301
+ optional: false
36302
+ }],
36194
36303
  "recording.getDeviceConfig": [{
36195
36304
  name: "deviceId",
36196
36305
  form: "single",
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@camstack/addon-decoder-nodeav",
3
- "version": "1.2.51",
3
+ "version": "1.2.52",
4
4
  "description": "Standalone in-process node-av decoder addon for CamStack",
5
5
  "keywords": [
6
6
  "camstack",