@camstack/addon-provider-petkit 0.2.51 → 0.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/addon.js +115 -6
- package/dist/addon.mjs +115 -6
- package/package.json +1 -1
package/dist/addon.js
CHANGED
|
@@ -20310,6 +20310,34 @@ var KeyEventsForDeviceSchema = object({
|
|
|
20310
20310
|
deviceId: number(),
|
|
20311
20311
|
events: array(KeyEventSchema).readonly()
|
|
20312
20312
|
});
|
|
20313
|
+
/** One non-empty bucket of the timeline histogram. */
|
|
20314
|
+
var EventDensityBucketSchema = object({
|
|
20315
|
+
bucketStart: number(),
|
|
20316
|
+
motion: number().int(),
|
|
20317
|
+
object: number().int(),
|
|
20318
|
+
audio: number().int()
|
|
20319
|
+
});
|
|
20320
|
+
/**
|
|
20321
|
+
* One camera's row in a `getEventDensityBatch` answer.
|
|
20322
|
+
*
|
|
20323
|
+
* TWO facts, and the timeline draws them differently:
|
|
20324
|
+
*
|
|
20325
|
+
* - `read: 'read'` — the histogram for this camera. `buckets: []` is a real
|
|
20326
|
+
* claim: read, and nothing happened in the window.
|
|
20327
|
+
* - `read: 'unreadable'` — nobody could answer for this camera. `buckets` is
|
|
20328
|
+
* empty and that emptiness means NOTHING; the timeline must render unknown,
|
|
20329
|
+
* not quiet.
|
|
20330
|
+
*
|
|
20331
|
+
* Fanned out per camera the difference was free — one query rejected while the
|
|
20332
|
+
* others resolved — and collapsing to a batch is the exact moment it is lost
|
|
20333
|
+
* silently. Every requested id gets a row: a caller that asked for twelve and
|
|
20334
|
+
* got eleven cannot tell which one is missing, or that any is.
|
|
20335
|
+
*/
|
|
20336
|
+
var EventDensityForDeviceSchema = object({
|
|
20337
|
+
deviceId: number(),
|
|
20338
|
+
read: _enum(["read", "unreadable"]),
|
|
20339
|
+
buckets: array(EventDensityBucketSchema).readonly()
|
|
20340
|
+
});
|
|
20313
20341
|
object({
|
|
20314
20342
|
trackId: string(),
|
|
20315
20343
|
className: string(),
|
|
@@ -20620,12 +20648,12 @@ DeviceType.Camera, method(object({ deviceId: number() }), array(TrackSchema).rea
|
|
|
20620
20648
|
since: number(),
|
|
20621
20649
|
until: number(),
|
|
20622
20650
|
bucketMs: number().int().positive()
|
|
20623
|
-
}), array(object({
|
|
20624
|
-
|
|
20625
|
-
|
|
20626
|
-
|
|
20627
|
-
|
|
20628
|
-
})).readonly()), method(object({
|
|
20651
|
+
}), array(EventDensityBucketSchema).readonly()), method(object({
|
|
20652
|
+
deviceIds: array(number()).min(1).max(200),
|
|
20653
|
+
since: number(),
|
|
20654
|
+
until: number(),
|
|
20655
|
+
bucketMs: number().int().positive()
|
|
20656
|
+
}), array(EventDensityForDeviceSchema).readonly()), method(object({
|
|
20629
20657
|
deviceId: number(),
|
|
20630
20658
|
cutoffMs: number()
|
|
20631
20659
|
}), object({
|
|
@@ -29658,6 +29686,39 @@ var RecordingDaysSchema = object({
|
|
|
29658
29686
|
/** Local-midnight epochs (UTC ms) of days that have ≥1 recorded segment. */
|
|
29659
29687
|
days: array(number())
|
|
29660
29688
|
});
|
|
29689
|
+
/**
|
|
29690
|
+
* One camera's row in a `getAvailabilityBatch` answer.
|
|
29691
|
+
*
|
|
29692
|
+
* `ranges` is EXACTLY what `getAvailability` returns for that camera — the
|
|
29693
|
+
* batch collapses the transport, not the work — plus the one thing the singular
|
|
29694
|
+
* method never had to say:
|
|
29695
|
+
*
|
|
29696
|
+
* - `read: 'read'` — answered. `ranges: []` means "read, and this camera has
|
|
29697
|
+
* no footage in the window", which is a real claim.
|
|
29698
|
+
* - `read: 'unreadable'` — the recorder could not answer for this camera (its
|
|
29699
|
+
* calendar rung threw, its location is unmounted). `ranges` is empty and
|
|
29700
|
+
* that emptiness means NOTHING.
|
|
29701
|
+
*
|
|
29702
|
+
* A timeline that renders the second as the first tells an operator there is no
|
|
29703
|
+
* footage when the truth is that nobody looked.
|
|
29704
|
+
*/
|
|
29705
|
+
var RecordingAvailabilityForDeviceSchema = object({
|
|
29706
|
+
deviceId: number(),
|
|
29707
|
+
read: _enum(["read", "unreadable"]),
|
|
29708
|
+
ranges: array(RecordingRangeSchema).readonly()
|
|
29709
|
+
});
|
|
29710
|
+
/**
|
|
29711
|
+
* One camera's row in a `getDaysWithRecordingsBatch` answer. Same rule as
|
|
29712
|
+
* {@link RecordingAvailabilityForDeviceSchema}: `days: []` on a `'read'` row is
|
|
29713
|
+
* "no footage in this month", `read: 'unreadable'` is "nobody could look", and
|
|
29714
|
+
* the date-picker's day dots must not spell them the same.
|
|
29715
|
+
*/
|
|
29716
|
+
var RecordingDaysForDeviceSchema = object({
|
|
29717
|
+
deviceId: number(),
|
|
29718
|
+
read: _enum(["read", "unreadable"]),
|
|
29719
|
+
/** Local-midnight epochs (UTC ms) of days that have ≥1 recorded segment. */
|
|
29720
|
+
days: array(number()).readonly()
|
|
29721
|
+
});
|
|
29661
29722
|
var RecordingManifestSchema = object({
|
|
29662
29723
|
deviceId: number(),
|
|
29663
29724
|
/** Local filesystem path to the master playlist; null when no recording exists for the requested range. */
|
|
@@ -29892,6 +29953,13 @@ method(object({
|
|
|
29892
29953
|
}), RecordingAvailabilitySchema, {
|
|
29893
29954
|
kind: "query",
|
|
29894
29955
|
auth: "protected"
|
|
29956
|
+
}), method(object({
|
|
29957
|
+
deviceIds: array(number()).min(1).max(200),
|
|
29958
|
+
fromMs: number(),
|
|
29959
|
+
toMs: number()
|
|
29960
|
+
}), array(RecordingAvailabilityForDeviceSchema).readonly(), {
|
|
29961
|
+
kind: "query",
|
|
29962
|
+
auth: "protected"
|
|
29895
29963
|
}), method(object({
|
|
29896
29964
|
deviceId: number(),
|
|
29897
29965
|
fromMs: number(),
|
|
@@ -29900,6 +29968,14 @@ method(object({
|
|
|
29900
29968
|
}), RecordingDaysSchema, {
|
|
29901
29969
|
kind: "query",
|
|
29902
29970
|
auth: "protected"
|
|
29971
|
+
}), method(object({
|
|
29972
|
+
deviceIds: array(number()).min(1).max(200),
|
|
29973
|
+
fromMs: number(),
|
|
29974
|
+
toMs: number(),
|
|
29975
|
+
tzOffsetMinutes: number()
|
|
29976
|
+
}), array(RecordingDaysForDeviceSchema).readonly(), {
|
|
29977
|
+
kind: "query",
|
|
29978
|
+
auth: "protected"
|
|
29903
29979
|
}), method(object({
|
|
29904
29980
|
deviceId: number(),
|
|
29905
29981
|
fromMs: number(),
|
|
@@ -36796,6 +36872,12 @@ Object.freeze({
|
|
|
36796
36872
|
addonId: null,
|
|
36797
36873
|
access: "view"
|
|
36798
36874
|
},
|
|
36875
|
+
"pipelineAnalytics.getEventDensityBatch": {
|
|
36876
|
+
capName: "pipeline-analytics",
|
|
36877
|
+
capScope: "device",
|
|
36878
|
+
addonId: null,
|
|
36879
|
+
access: "view"
|
|
36880
|
+
},
|
|
36799
36881
|
"pipelineAnalytics.getEventMedia": {
|
|
36800
36882
|
capName: "pipeline-analytics",
|
|
36801
36883
|
capScope: "device",
|
|
@@ -37918,12 +38000,24 @@ Object.freeze({
|
|
|
37918
38000
|
addonId: null,
|
|
37919
38001
|
access: "view"
|
|
37920
38002
|
},
|
|
38003
|
+
"recording.getAvailabilityBatch": {
|
|
38004
|
+
capName: "recording",
|
|
38005
|
+
capScope: "system",
|
|
38006
|
+
addonId: null,
|
|
38007
|
+
access: "view"
|
|
38008
|
+
},
|
|
37921
38009
|
"recording.getDaysWithRecordings": {
|
|
37922
38010
|
capName: "recording",
|
|
37923
38011
|
capScope: "system",
|
|
37924
38012
|
addonId: null,
|
|
37925
38013
|
access: "view"
|
|
37926
38014
|
},
|
|
38015
|
+
"recording.getDaysWithRecordingsBatch": {
|
|
38016
|
+
capName: "recording",
|
|
38017
|
+
capScope: "system",
|
|
38018
|
+
addonId: null,
|
|
38019
|
+
access: "view"
|
|
38020
|
+
},
|
|
37927
38021
|
"recording.getDeviceConfig": {
|
|
37928
38022
|
capName: "recording",
|
|
37929
38023
|
capScope: "system",
|
|
@@ -40528,6 +40622,11 @@ Object.freeze({
|
|
|
40528
40622
|
form: "single",
|
|
40529
40623
|
optional: false
|
|
40530
40624
|
}],
|
|
40625
|
+
"pipelineAnalytics.getEventDensityBatch": [{
|
|
40626
|
+
name: "deviceIds",
|
|
40627
|
+
form: "array",
|
|
40628
|
+
optional: false
|
|
40629
|
+
}],
|
|
40531
40630
|
"pipelineAnalytics.getEventMedia": [{
|
|
40532
40631
|
name: "deviceId",
|
|
40533
40632
|
form: "single",
|
|
@@ -40943,11 +41042,21 @@ Object.freeze({
|
|
|
40943
41042
|
form: "single",
|
|
40944
41043
|
optional: false
|
|
40945
41044
|
}],
|
|
41045
|
+
"recording.getAvailabilityBatch": [{
|
|
41046
|
+
name: "deviceIds",
|
|
41047
|
+
form: "array",
|
|
41048
|
+
optional: false
|
|
41049
|
+
}],
|
|
40946
41050
|
"recording.getDaysWithRecordings": [{
|
|
40947
41051
|
name: "deviceId",
|
|
40948
41052
|
form: "single",
|
|
40949
41053
|
optional: false
|
|
40950
41054
|
}],
|
|
41055
|
+
"recording.getDaysWithRecordingsBatch": [{
|
|
41056
|
+
name: "deviceIds",
|
|
41057
|
+
form: "array",
|
|
41058
|
+
optional: false
|
|
41059
|
+
}],
|
|
40951
41060
|
"recording.getDeviceConfig": [{
|
|
40952
41061
|
name: "deviceId",
|
|
40953
41062
|
form: "single",
|
package/dist/addon.mjs
CHANGED
|
@@ -20309,6 +20309,34 @@ var KeyEventsForDeviceSchema = object({
|
|
|
20309
20309
|
deviceId: number(),
|
|
20310
20310
|
events: array(KeyEventSchema).readonly()
|
|
20311
20311
|
});
|
|
20312
|
+
/** One non-empty bucket of the timeline histogram. */
|
|
20313
|
+
var EventDensityBucketSchema = object({
|
|
20314
|
+
bucketStart: number(),
|
|
20315
|
+
motion: number().int(),
|
|
20316
|
+
object: number().int(),
|
|
20317
|
+
audio: number().int()
|
|
20318
|
+
});
|
|
20319
|
+
/**
|
|
20320
|
+
* One camera's row in a `getEventDensityBatch` answer.
|
|
20321
|
+
*
|
|
20322
|
+
* TWO facts, and the timeline draws them differently:
|
|
20323
|
+
*
|
|
20324
|
+
* - `read: 'read'` — the histogram for this camera. `buckets: []` is a real
|
|
20325
|
+
* claim: read, and nothing happened in the window.
|
|
20326
|
+
* - `read: 'unreadable'` — nobody could answer for this camera. `buckets` is
|
|
20327
|
+
* empty and that emptiness means NOTHING; the timeline must render unknown,
|
|
20328
|
+
* not quiet.
|
|
20329
|
+
*
|
|
20330
|
+
* Fanned out per camera the difference was free — one query rejected while the
|
|
20331
|
+
* others resolved — and collapsing to a batch is the exact moment it is lost
|
|
20332
|
+
* silently. Every requested id gets a row: a caller that asked for twelve and
|
|
20333
|
+
* got eleven cannot tell which one is missing, or that any is.
|
|
20334
|
+
*/
|
|
20335
|
+
var EventDensityForDeviceSchema = object({
|
|
20336
|
+
deviceId: number(),
|
|
20337
|
+
read: _enum(["read", "unreadable"]),
|
|
20338
|
+
buckets: array(EventDensityBucketSchema).readonly()
|
|
20339
|
+
});
|
|
20312
20340
|
object({
|
|
20313
20341
|
trackId: string(),
|
|
20314
20342
|
className: string(),
|
|
@@ -20619,12 +20647,12 @@ DeviceType.Camera, method(object({ deviceId: number() }), array(TrackSchema).rea
|
|
|
20619
20647
|
since: number(),
|
|
20620
20648
|
until: number(),
|
|
20621
20649
|
bucketMs: number().int().positive()
|
|
20622
|
-
}), array(object({
|
|
20623
|
-
|
|
20624
|
-
|
|
20625
|
-
|
|
20626
|
-
|
|
20627
|
-
})).readonly()), method(object({
|
|
20650
|
+
}), array(EventDensityBucketSchema).readonly()), method(object({
|
|
20651
|
+
deviceIds: array(number()).min(1).max(200),
|
|
20652
|
+
since: number(),
|
|
20653
|
+
until: number(),
|
|
20654
|
+
bucketMs: number().int().positive()
|
|
20655
|
+
}), array(EventDensityForDeviceSchema).readonly()), method(object({
|
|
20628
20656
|
deviceId: number(),
|
|
20629
20657
|
cutoffMs: number()
|
|
20630
20658
|
}), object({
|
|
@@ -29657,6 +29685,39 @@ var RecordingDaysSchema = object({
|
|
|
29657
29685
|
/** Local-midnight epochs (UTC ms) of days that have ≥1 recorded segment. */
|
|
29658
29686
|
days: array(number())
|
|
29659
29687
|
});
|
|
29688
|
+
/**
|
|
29689
|
+
* One camera's row in a `getAvailabilityBatch` answer.
|
|
29690
|
+
*
|
|
29691
|
+
* `ranges` is EXACTLY what `getAvailability` returns for that camera — the
|
|
29692
|
+
* batch collapses the transport, not the work — plus the one thing the singular
|
|
29693
|
+
* method never had to say:
|
|
29694
|
+
*
|
|
29695
|
+
* - `read: 'read'` — answered. `ranges: []` means "read, and this camera has
|
|
29696
|
+
* no footage in the window", which is a real claim.
|
|
29697
|
+
* - `read: 'unreadable'` — the recorder could not answer for this camera (its
|
|
29698
|
+
* calendar rung threw, its location is unmounted). `ranges` is empty and
|
|
29699
|
+
* that emptiness means NOTHING.
|
|
29700
|
+
*
|
|
29701
|
+
* A timeline that renders the second as the first tells an operator there is no
|
|
29702
|
+
* footage when the truth is that nobody looked.
|
|
29703
|
+
*/
|
|
29704
|
+
var RecordingAvailabilityForDeviceSchema = object({
|
|
29705
|
+
deviceId: number(),
|
|
29706
|
+
read: _enum(["read", "unreadable"]),
|
|
29707
|
+
ranges: array(RecordingRangeSchema).readonly()
|
|
29708
|
+
});
|
|
29709
|
+
/**
|
|
29710
|
+
* One camera's row in a `getDaysWithRecordingsBatch` answer. Same rule as
|
|
29711
|
+
* {@link RecordingAvailabilityForDeviceSchema}: `days: []` on a `'read'` row is
|
|
29712
|
+
* "no footage in this month", `read: 'unreadable'` is "nobody could look", and
|
|
29713
|
+
* the date-picker's day dots must not spell them the same.
|
|
29714
|
+
*/
|
|
29715
|
+
var RecordingDaysForDeviceSchema = object({
|
|
29716
|
+
deviceId: number(),
|
|
29717
|
+
read: _enum(["read", "unreadable"]),
|
|
29718
|
+
/** Local-midnight epochs (UTC ms) of days that have ≥1 recorded segment. */
|
|
29719
|
+
days: array(number()).readonly()
|
|
29720
|
+
});
|
|
29660
29721
|
var RecordingManifestSchema = object({
|
|
29661
29722
|
deviceId: number(),
|
|
29662
29723
|
/** Local filesystem path to the master playlist; null when no recording exists for the requested range. */
|
|
@@ -29891,6 +29952,13 @@ method(object({
|
|
|
29891
29952
|
}), RecordingAvailabilitySchema, {
|
|
29892
29953
|
kind: "query",
|
|
29893
29954
|
auth: "protected"
|
|
29955
|
+
}), method(object({
|
|
29956
|
+
deviceIds: array(number()).min(1).max(200),
|
|
29957
|
+
fromMs: number(),
|
|
29958
|
+
toMs: number()
|
|
29959
|
+
}), array(RecordingAvailabilityForDeviceSchema).readonly(), {
|
|
29960
|
+
kind: "query",
|
|
29961
|
+
auth: "protected"
|
|
29894
29962
|
}), method(object({
|
|
29895
29963
|
deviceId: number(),
|
|
29896
29964
|
fromMs: number(),
|
|
@@ -29899,6 +29967,14 @@ method(object({
|
|
|
29899
29967
|
}), RecordingDaysSchema, {
|
|
29900
29968
|
kind: "query",
|
|
29901
29969
|
auth: "protected"
|
|
29970
|
+
}), method(object({
|
|
29971
|
+
deviceIds: array(number()).min(1).max(200),
|
|
29972
|
+
fromMs: number(),
|
|
29973
|
+
toMs: number(),
|
|
29974
|
+
tzOffsetMinutes: number()
|
|
29975
|
+
}), array(RecordingDaysForDeviceSchema).readonly(), {
|
|
29976
|
+
kind: "query",
|
|
29977
|
+
auth: "protected"
|
|
29902
29978
|
}), method(object({
|
|
29903
29979
|
deviceId: number(),
|
|
29904
29980
|
fromMs: number(),
|
|
@@ -36795,6 +36871,12 @@ Object.freeze({
|
|
|
36795
36871
|
addonId: null,
|
|
36796
36872
|
access: "view"
|
|
36797
36873
|
},
|
|
36874
|
+
"pipelineAnalytics.getEventDensityBatch": {
|
|
36875
|
+
capName: "pipeline-analytics",
|
|
36876
|
+
capScope: "device",
|
|
36877
|
+
addonId: null,
|
|
36878
|
+
access: "view"
|
|
36879
|
+
},
|
|
36798
36880
|
"pipelineAnalytics.getEventMedia": {
|
|
36799
36881
|
capName: "pipeline-analytics",
|
|
36800
36882
|
capScope: "device",
|
|
@@ -37917,12 +37999,24 @@ Object.freeze({
|
|
|
37917
37999
|
addonId: null,
|
|
37918
38000
|
access: "view"
|
|
37919
38001
|
},
|
|
38002
|
+
"recording.getAvailabilityBatch": {
|
|
38003
|
+
capName: "recording",
|
|
38004
|
+
capScope: "system",
|
|
38005
|
+
addonId: null,
|
|
38006
|
+
access: "view"
|
|
38007
|
+
},
|
|
37920
38008
|
"recording.getDaysWithRecordings": {
|
|
37921
38009
|
capName: "recording",
|
|
37922
38010
|
capScope: "system",
|
|
37923
38011
|
addonId: null,
|
|
37924
38012
|
access: "view"
|
|
37925
38013
|
},
|
|
38014
|
+
"recording.getDaysWithRecordingsBatch": {
|
|
38015
|
+
capName: "recording",
|
|
38016
|
+
capScope: "system",
|
|
38017
|
+
addonId: null,
|
|
38018
|
+
access: "view"
|
|
38019
|
+
},
|
|
37926
38020
|
"recording.getDeviceConfig": {
|
|
37927
38021
|
capName: "recording",
|
|
37928
38022
|
capScope: "system",
|
|
@@ -40527,6 +40621,11 @@ Object.freeze({
|
|
|
40527
40621
|
form: "single",
|
|
40528
40622
|
optional: false
|
|
40529
40623
|
}],
|
|
40624
|
+
"pipelineAnalytics.getEventDensityBatch": [{
|
|
40625
|
+
name: "deviceIds",
|
|
40626
|
+
form: "array",
|
|
40627
|
+
optional: false
|
|
40628
|
+
}],
|
|
40530
40629
|
"pipelineAnalytics.getEventMedia": [{
|
|
40531
40630
|
name: "deviceId",
|
|
40532
40631
|
form: "single",
|
|
@@ -40942,11 +41041,21 @@ Object.freeze({
|
|
|
40942
41041
|
form: "single",
|
|
40943
41042
|
optional: false
|
|
40944
41043
|
}],
|
|
41044
|
+
"recording.getAvailabilityBatch": [{
|
|
41045
|
+
name: "deviceIds",
|
|
41046
|
+
form: "array",
|
|
41047
|
+
optional: false
|
|
41048
|
+
}],
|
|
40945
41049
|
"recording.getDaysWithRecordings": [{
|
|
40946
41050
|
name: "deviceId",
|
|
40947
41051
|
form: "single",
|
|
40948
41052
|
optional: false
|
|
40949
41053
|
}],
|
|
41054
|
+
"recording.getDaysWithRecordingsBatch": [{
|
|
41055
|
+
name: "deviceIds",
|
|
41056
|
+
form: "array",
|
|
41057
|
+
optional: false
|
|
41058
|
+
}],
|
|
40950
41059
|
"recording.getDeviceConfig": [{
|
|
40951
41060
|
name: "deviceId",
|
|
40952
41061
|
form: "single",
|
package/package.json
CHANGED