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