@camstack/addon-provider-petkit 0.2.50 → 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 +117 -6
- package/dist/addon.mjs +117 -6
- package/package.json +1 -1
package/dist/addon.js
CHANGED
|
@@ -16994,6 +16994,8 @@ var NcSystemEventKindSchema = _enum([
|
|
|
16994
16994
|
"device-offline",
|
|
16995
16995
|
"device-disabled",
|
|
16996
16996
|
"device-enabled",
|
|
16997
|
+
"device-battery-low",
|
|
16998
|
+
"device-battery-normal",
|
|
16997
16999
|
"stream-online",
|
|
16998
17000
|
"stream-offline",
|
|
16999
17001
|
"node-online",
|
|
@@ -20308,6 +20310,34 @@ var KeyEventsForDeviceSchema = object({
|
|
|
20308
20310
|
deviceId: number(),
|
|
20309
20311
|
events: array(KeyEventSchema).readonly()
|
|
20310
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
|
+
});
|
|
20311
20341
|
object({
|
|
20312
20342
|
trackId: string(),
|
|
20313
20343
|
className: string(),
|
|
@@ -20618,12 +20648,12 @@ DeviceType.Camera, method(object({ deviceId: number() }), array(TrackSchema).rea
|
|
|
20618
20648
|
since: number(),
|
|
20619
20649
|
until: number(),
|
|
20620
20650
|
bucketMs: number().int().positive()
|
|
20621
|
-
}), array(object({
|
|
20622
|
-
|
|
20623
|
-
|
|
20624
|
-
|
|
20625
|
-
|
|
20626
|
-
})).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({
|
|
20627
20657
|
deviceId: number(),
|
|
20628
20658
|
cutoffMs: number()
|
|
20629
20659
|
}), object({
|
|
@@ -29656,6 +29686,39 @@ var RecordingDaysSchema = object({
|
|
|
29656
29686
|
/** Local-midnight epochs (UTC ms) of days that have ≥1 recorded segment. */
|
|
29657
29687
|
days: array(number())
|
|
29658
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
|
+
});
|
|
29659
29722
|
var RecordingManifestSchema = object({
|
|
29660
29723
|
deviceId: number(),
|
|
29661
29724
|
/** Local filesystem path to the master playlist; null when no recording exists for the requested range. */
|
|
@@ -29890,6 +29953,13 @@ method(object({
|
|
|
29890
29953
|
}), RecordingAvailabilitySchema, {
|
|
29891
29954
|
kind: "query",
|
|
29892
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"
|
|
29893
29963
|
}), method(object({
|
|
29894
29964
|
deviceId: number(),
|
|
29895
29965
|
fromMs: number(),
|
|
@@ -29898,6 +29968,14 @@ method(object({
|
|
|
29898
29968
|
}), RecordingDaysSchema, {
|
|
29899
29969
|
kind: "query",
|
|
29900
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"
|
|
29901
29979
|
}), method(object({
|
|
29902
29980
|
deviceId: number(),
|
|
29903
29981
|
fromMs: number(),
|
|
@@ -36794,6 +36872,12 @@ Object.freeze({
|
|
|
36794
36872
|
addonId: null,
|
|
36795
36873
|
access: "view"
|
|
36796
36874
|
},
|
|
36875
|
+
"pipelineAnalytics.getEventDensityBatch": {
|
|
36876
|
+
capName: "pipeline-analytics",
|
|
36877
|
+
capScope: "device",
|
|
36878
|
+
addonId: null,
|
|
36879
|
+
access: "view"
|
|
36880
|
+
},
|
|
36797
36881
|
"pipelineAnalytics.getEventMedia": {
|
|
36798
36882
|
capName: "pipeline-analytics",
|
|
36799
36883
|
capScope: "device",
|
|
@@ -37916,12 +38000,24 @@ Object.freeze({
|
|
|
37916
38000
|
addonId: null,
|
|
37917
38001
|
access: "view"
|
|
37918
38002
|
},
|
|
38003
|
+
"recording.getAvailabilityBatch": {
|
|
38004
|
+
capName: "recording",
|
|
38005
|
+
capScope: "system",
|
|
38006
|
+
addonId: null,
|
|
38007
|
+
access: "view"
|
|
38008
|
+
},
|
|
37919
38009
|
"recording.getDaysWithRecordings": {
|
|
37920
38010
|
capName: "recording",
|
|
37921
38011
|
capScope: "system",
|
|
37922
38012
|
addonId: null,
|
|
37923
38013
|
access: "view"
|
|
37924
38014
|
},
|
|
38015
|
+
"recording.getDaysWithRecordingsBatch": {
|
|
38016
|
+
capName: "recording",
|
|
38017
|
+
capScope: "system",
|
|
38018
|
+
addonId: null,
|
|
38019
|
+
access: "view"
|
|
38020
|
+
},
|
|
37925
38021
|
"recording.getDeviceConfig": {
|
|
37926
38022
|
capName: "recording",
|
|
37927
38023
|
capScope: "system",
|
|
@@ -40526,6 +40622,11 @@ Object.freeze({
|
|
|
40526
40622
|
form: "single",
|
|
40527
40623
|
optional: false
|
|
40528
40624
|
}],
|
|
40625
|
+
"pipelineAnalytics.getEventDensityBatch": [{
|
|
40626
|
+
name: "deviceIds",
|
|
40627
|
+
form: "array",
|
|
40628
|
+
optional: false
|
|
40629
|
+
}],
|
|
40529
40630
|
"pipelineAnalytics.getEventMedia": [{
|
|
40530
40631
|
name: "deviceId",
|
|
40531
40632
|
form: "single",
|
|
@@ -40941,11 +41042,21 @@ Object.freeze({
|
|
|
40941
41042
|
form: "single",
|
|
40942
41043
|
optional: false
|
|
40943
41044
|
}],
|
|
41045
|
+
"recording.getAvailabilityBatch": [{
|
|
41046
|
+
name: "deviceIds",
|
|
41047
|
+
form: "array",
|
|
41048
|
+
optional: false
|
|
41049
|
+
}],
|
|
40944
41050
|
"recording.getDaysWithRecordings": [{
|
|
40945
41051
|
name: "deviceId",
|
|
40946
41052
|
form: "single",
|
|
40947
41053
|
optional: false
|
|
40948
41054
|
}],
|
|
41055
|
+
"recording.getDaysWithRecordingsBatch": [{
|
|
41056
|
+
name: "deviceIds",
|
|
41057
|
+
form: "array",
|
|
41058
|
+
optional: false
|
|
41059
|
+
}],
|
|
40949
41060
|
"recording.getDeviceConfig": [{
|
|
40950
41061
|
name: "deviceId",
|
|
40951
41062
|
form: "single",
|
package/dist/addon.mjs
CHANGED
|
@@ -16993,6 +16993,8 @@ var NcSystemEventKindSchema = _enum([
|
|
|
16993
16993
|
"device-offline",
|
|
16994
16994
|
"device-disabled",
|
|
16995
16995
|
"device-enabled",
|
|
16996
|
+
"device-battery-low",
|
|
16997
|
+
"device-battery-normal",
|
|
16996
16998
|
"stream-online",
|
|
16997
16999
|
"stream-offline",
|
|
16998
17000
|
"node-online",
|
|
@@ -20307,6 +20309,34 @@ var KeyEventsForDeviceSchema = object({
|
|
|
20307
20309
|
deviceId: number(),
|
|
20308
20310
|
events: array(KeyEventSchema).readonly()
|
|
20309
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
|
+
});
|
|
20310
20340
|
object({
|
|
20311
20341
|
trackId: string(),
|
|
20312
20342
|
className: string(),
|
|
@@ -20617,12 +20647,12 @@ DeviceType.Camera, method(object({ deviceId: number() }), array(TrackSchema).rea
|
|
|
20617
20647
|
since: number(),
|
|
20618
20648
|
until: number(),
|
|
20619
20649
|
bucketMs: number().int().positive()
|
|
20620
|
-
}), array(object({
|
|
20621
|
-
|
|
20622
|
-
|
|
20623
|
-
|
|
20624
|
-
|
|
20625
|
-
})).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({
|
|
20626
20656
|
deviceId: number(),
|
|
20627
20657
|
cutoffMs: number()
|
|
20628
20658
|
}), object({
|
|
@@ -29655,6 +29685,39 @@ var RecordingDaysSchema = object({
|
|
|
29655
29685
|
/** Local-midnight epochs (UTC ms) of days that have ≥1 recorded segment. */
|
|
29656
29686
|
days: array(number())
|
|
29657
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
|
+
});
|
|
29658
29721
|
var RecordingManifestSchema = object({
|
|
29659
29722
|
deviceId: number(),
|
|
29660
29723
|
/** Local filesystem path to the master playlist; null when no recording exists for the requested range. */
|
|
@@ -29889,6 +29952,13 @@ method(object({
|
|
|
29889
29952
|
}), RecordingAvailabilitySchema, {
|
|
29890
29953
|
kind: "query",
|
|
29891
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"
|
|
29892
29962
|
}), method(object({
|
|
29893
29963
|
deviceId: number(),
|
|
29894
29964
|
fromMs: number(),
|
|
@@ -29897,6 +29967,14 @@ method(object({
|
|
|
29897
29967
|
}), RecordingDaysSchema, {
|
|
29898
29968
|
kind: "query",
|
|
29899
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"
|
|
29900
29978
|
}), method(object({
|
|
29901
29979
|
deviceId: number(),
|
|
29902
29980
|
fromMs: number(),
|
|
@@ -36793,6 +36871,12 @@ Object.freeze({
|
|
|
36793
36871
|
addonId: null,
|
|
36794
36872
|
access: "view"
|
|
36795
36873
|
},
|
|
36874
|
+
"pipelineAnalytics.getEventDensityBatch": {
|
|
36875
|
+
capName: "pipeline-analytics",
|
|
36876
|
+
capScope: "device",
|
|
36877
|
+
addonId: null,
|
|
36878
|
+
access: "view"
|
|
36879
|
+
},
|
|
36796
36880
|
"pipelineAnalytics.getEventMedia": {
|
|
36797
36881
|
capName: "pipeline-analytics",
|
|
36798
36882
|
capScope: "device",
|
|
@@ -37915,12 +37999,24 @@ Object.freeze({
|
|
|
37915
37999
|
addonId: null,
|
|
37916
38000
|
access: "view"
|
|
37917
38001
|
},
|
|
38002
|
+
"recording.getAvailabilityBatch": {
|
|
38003
|
+
capName: "recording",
|
|
38004
|
+
capScope: "system",
|
|
38005
|
+
addonId: null,
|
|
38006
|
+
access: "view"
|
|
38007
|
+
},
|
|
37918
38008
|
"recording.getDaysWithRecordings": {
|
|
37919
38009
|
capName: "recording",
|
|
37920
38010
|
capScope: "system",
|
|
37921
38011
|
addonId: null,
|
|
37922
38012
|
access: "view"
|
|
37923
38013
|
},
|
|
38014
|
+
"recording.getDaysWithRecordingsBatch": {
|
|
38015
|
+
capName: "recording",
|
|
38016
|
+
capScope: "system",
|
|
38017
|
+
addonId: null,
|
|
38018
|
+
access: "view"
|
|
38019
|
+
},
|
|
37924
38020
|
"recording.getDeviceConfig": {
|
|
37925
38021
|
capName: "recording",
|
|
37926
38022
|
capScope: "system",
|
|
@@ -40525,6 +40621,11 @@ Object.freeze({
|
|
|
40525
40621
|
form: "single",
|
|
40526
40622
|
optional: false
|
|
40527
40623
|
}],
|
|
40624
|
+
"pipelineAnalytics.getEventDensityBatch": [{
|
|
40625
|
+
name: "deviceIds",
|
|
40626
|
+
form: "array",
|
|
40627
|
+
optional: false
|
|
40628
|
+
}],
|
|
40528
40629
|
"pipelineAnalytics.getEventMedia": [{
|
|
40529
40630
|
name: "deviceId",
|
|
40530
40631
|
form: "single",
|
|
@@ -40940,11 +41041,21 @@ Object.freeze({
|
|
|
40940
41041
|
form: "single",
|
|
40941
41042
|
optional: false
|
|
40942
41043
|
}],
|
|
41044
|
+
"recording.getAvailabilityBatch": [{
|
|
41045
|
+
name: "deviceIds",
|
|
41046
|
+
form: "array",
|
|
41047
|
+
optional: false
|
|
41048
|
+
}],
|
|
40943
41049
|
"recording.getDaysWithRecordings": [{
|
|
40944
41050
|
name: "deviceId",
|
|
40945
41051
|
form: "single",
|
|
40946
41052
|
optional: false
|
|
40947
41053
|
}],
|
|
41054
|
+
"recording.getDaysWithRecordingsBatch": [{
|
|
41055
|
+
name: "deviceIds",
|
|
41056
|
+
form: "array",
|
|
41057
|
+
optional: false
|
|
41058
|
+
}],
|
|
40948
41059
|
"recording.getDeviceConfig": [{
|
|
40949
41060
|
name: "deviceId",
|
|
40950
41061
|
form: "single",
|
package/package.json
CHANGED