@camstack/addon-export-hap 1.2.62 → 1.2.63
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/hap-export.addon.js +115 -6
- package/dist/hap-export.addon.mjs +115 -6
- package/package.json +1 -1
package/dist/hap-export.addon.js
CHANGED
|
@@ -19650,6 +19650,34 @@ var KeyEventsForDeviceSchema = object({
|
|
|
19650
19650
|
deviceId: number(),
|
|
19651
19651
|
events: array(KeyEventSchema).readonly()
|
|
19652
19652
|
});
|
|
19653
|
+
/** One non-empty bucket of the timeline histogram. */
|
|
19654
|
+
var EventDensityBucketSchema = object({
|
|
19655
|
+
bucketStart: number(),
|
|
19656
|
+
motion: number().int(),
|
|
19657
|
+
object: number().int(),
|
|
19658
|
+
audio: number().int()
|
|
19659
|
+
});
|
|
19660
|
+
/**
|
|
19661
|
+
* One camera's row in a `getEventDensityBatch` answer.
|
|
19662
|
+
*
|
|
19663
|
+
* TWO facts, and the timeline draws them differently:
|
|
19664
|
+
*
|
|
19665
|
+
* - `read: 'read'` — the histogram for this camera. `buckets: []` is a real
|
|
19666
|
+
* claim: read, and nothing happened in the window.
|
|
19667
|
+
* - `read: 'unreadable'` — nobody could answer for this camera. `buckets` is
|
|
19668
|
+
* empty and that emptiness means NOTHING; the timeline must render unknown,
|
|
19669
|
+
* not quiet.
|
|
19670
|
+
*
|
|
19671
|
+
* Fanned out per camera the difference was free — one query rejected while the
|
|
19672
|
+
* others resolved — and collapsing to a batch is the exact moment it is lost
|
|
19673
|
+
* silently. Every requested id gets a row: a caller that asked for twelve and
|
|
19674
|
+
* got eleven cannot tell which one is missing, or that any is.
|
|
19675
|
+
*/
|
|
19676
|
+
var EventDensityForDeviceSchema = object({
|
|
19677
|
+
deviceId: number(),
|
|
19678
|
+
read: _enum(["read", "unreadable"]),
|
|
19679
|
+
buckets: array(EventDensityBucketSchema).readonly()
|
|
19680
|
+
});
|
|
19653
19681
|
object({
|
|
19654
19682
|
trackId: string(),
|
|
19655
19683
|
className: string(),
|
|
@@ -19960,12 +19988,12 @@ DeviceType.Camera, method(object({ deviceId: number() }), array(TrackSchema).rea
|
|
|
19960
19988
|
since: number(),
|
|
19961
19989
|
until: number(),
|
|
19962
19990
|
bucketMs: number().int().positive()
|
|
19963
|
-
}), array(object({
|
|
19964
|
-
|
|
19965
|
-
|
|
19966
|
-
|
|
19967
|
-
|
|
19968
|
-
})).readonly()), method(object({
|
|
19991
|
+
}), array(EventDensityBucketSchema).readonly()), method(object({
|
|
19992
|
+
deviceIds: array(number()).min(1).max(200),
|
|
19993
|
+
since: number(),
|
|
19994
|
+
until: number(),
|
|
19995
|
+
bucketMs: number().int().positive()
|
|
19996
|
+
}), array(EventDensityForDeviceSchema).readonly()), method(object({
|
|
19969
19997
|
deviceId: number(),
|
|
19970
19998
|
cutoffMs: number()
|
|
19971
19999
|
}), object({
|
|
@@ -27323,6 +27351,39 @@ var RecordingDaysSchema = object({
|
|
|
27323
27351
|
/** Local-midnight epochs (UTC ms) of days that have ≥1 recorded segment. */
|
|
27324
27352
|
days: array(number())
|
|
27325
27353
|
});
|
|
27354
|
+
/**
|
|
27355
|
+
* One camera's row in a `getAvailabilityBatch` answer.
|
|
27356
|
+
*
|
|
27357
|
+
* `ranges` is EXACTLY what `getAvailability` returns for that camera — the
|
|
27358
|
+
* batch collapses the transport, not the work — plus the one thing the singular
|
|
27359
|
+
* method never had to say:
|
|
27360
|
+
*
|
|
27361
|
+
* - `read: 'read'` — answered. `ranges: []` means "read, and this camera has
|
|
27362
|
+
* no footage in the window", which is a real claim.
|
|
27363
|
+
* - `read: 'unreadable'` — the recorder could not answer for this camera (its
|
|
27364
|
+
* calendar rung threw, its location is unmounted). `ranges` is empty and
|
|
27365
|
+
* that emptiness means NOTHING.
|
|
27366
|
+
*
|
|
27367
|
+
* A timeline that renders the second as the first tells an operator there is no
|
|
27368
|
+
* footage when the truth is that nobody looked.
|
|
27369
|
+
*/
|
|
27370
|
+
var RecordingAvailabilityForDeviceSchema = object({
|
|
27371
|
+
deviceId: number(),
|
|
27372
|
+
read: _enum(["read", "unreadable"]),
|
|
27373
|
+
ranges: array(RecordingRangeSchema).readonly()
|
|
27374
|
+
});
|
|
27375
|
+
/**
|
|
27376
|
+
* One camera's row in a `getDaysWithRecordingsBatch` answer. Same rule as
|
|
27377
|
+
* {@link RecordingAvailabilityForDeviceSchema}: `days: []` on a `'read'` row is
|
|
27378
|
+
* "no footage in this month", `read: 'unreadable'` is "nobody could look", and
|
|
27379
|
+
* the date-picker's day dots must not spell them the same.
|
|
27380
|
+
*/
|
|
27381
|
+
var RecordingDaysForDeviceSchema = object({
|
|
27382
|
+
deviceId: number(),
|
|
27383
|
+
read: _enum(["read", "unreadable"]),
|
|
27384
|
+
/** Local-midnight epochs (UTC ms) of days that have ≥1 recorded segment. */
|
|
27385
|
+
days: array(number()).readonly()
|
|
27386
|
+
});
|
|
27326
27387
|
var RecordingManifestSchema = object({
|
|
27327
27388
|
deviceId: number(),
|
|
27328
27389
|
/** Local filesystem path to the master playlist; null when no recording exists for the requested range. */
|
|
@@ -27557,6 +27618,13 @@ method(object({
|
|
|
27557
27618
|
}), RecordingAvailabilitySchema, {
|
|
27558
27619
|
kind: "query",
|
|
27559
27620
|
auth: "protected"
|
|
27621
|
+
}), method(object({
|
|
27622
|
+
deviceIds: array(number()).min(1).max(200),
|
|
27623
|
+
fromMs: number(),
|
|
27624
|
+
toMs: number()
|
|
27625
|
+
}), array(RecordingAvailabilityForDeviceSchema).readonly(), {
|
|
27626
|
+
kind: "query",
|
|
27627
|
+
auth: "protected"
|
|
27560
27628
|
}), method(object({
|
|
27561
27629
|
deviceId: number(),
|
|
27562
27630
|
fromMs: number(),
|
|
@@ -27565,6 +27633,14 @@ method(object({
|
|
|
27565
27633
|
}), RecordingDaysSchema, {
|
|
27566
27634
|
kind: "query",
|
|
27567
27635
|
auth: "protected"
|
|
27636
|
+
}), method(object({
|
|
27637
|
+
deviceIds: array(number()).min(1).max(200),
|
|
27638
|
+
fromMs: number(),
|
|
27639
|
+
toMs: number(),
|
|
27640
|
+
tzOffsetMinutes: number()
|
|
27641
|
+
}), array(RecordingDaysForDeviceSchema).readonly(), {
|
|
27642
|
+
kind: "query",
|
|
27643
|
+
auth: "protected"
|
|
27568
27644
|
}), method(object({
|
|
27569
27645
|
deviceId: number(),
|
|
27570
27646
|
fromMs: number(),
|
|
@@ -32787,6 +32863,12 @@ Object.freeze({
|
|
|
32787
32863
|
addonId: null,
|
|
32788
32864
|
access: "view"
|
|
32789
32865
|
},
|
|
32866
|
+
"pipelineAnalytics.getEventDensityBatch": {
|
|
32867
|
+
capName: "pipeline-analytics",
|
|
32868
|
+
capScope: "device",
|
|
32869
|
+
addonId: null,
|
|
32870
|
+
access: "view"
|
|
32871
|
+
},
|
|
32790
32872
|
"pipelineAnalytics.getEventMedia": {
|
|
32791
32873
|
capName: "pipeline-analytics",
|
|
32792
32874
|
capScope: "device",
|
|
@@ -33909,12 +33991,24 @@ Object.freeze({
|
|
|
33909
33991
|
addonId: null,
|
|
33910
33992
|
access: "view"
|
|
33911
33993
|
},
|
|
33994
|
+
"recording.getAvailabilityBatch": {
|
|
33995
|
+
capName: "recording",
|
|
33996
|
+
capScope: "system",
|
|
33997
|
+
addonId: null,
|
|
33998
|
+
access: "view"
|
|
33999
|
+
},
|
|
33912
34000
|
"recording.getDaysWithRecordings": {
|
|
33913
34001
|
capName: "recording",
|
|
33914
34002
|
capScope: "system",
|
|
33915
34003
|
addonId: null,
|
|
33916
34004
|
access: "view"
|
|
33917
34005
|
},
|
|
34006
|
+
"recording.getDaysWithRecordingsBatch": {
|
|
34007
|
+
capName: "recording",
|
|
34008
|
+
capScope: "system",
|
|
34009
|
+
addonId: null,
|
|
34010
|
+
access: "view"
|
|
34011
|
+
},
|
|
33918
34012
|
"recording.getDeviceConfig": {
|
|
33919
34013
|
capName: "recording",
|
|
33920
34014
|
capScope: "system",
|
|
@@ -36519,6 +36613,11 @@ Object.freeze({
|
|
|
36519
36613
|
form: "single",
|
|
36520
36614
|
optional: false
|
|
36521
36615
|
}],
|
|
36616
|
+
"pipelineAnalytics.getEventDensityBatch": [{
|
|
36617
|
+
name: "deviceIds",
|
|
36618
|
+
form: "array",
|
|
36619
|
+
optional: false
|
|
36620
|
+
}],
|
|
36522
36621
|
"pipelineAnalytics.getEventMedia": [{
|
|
36523
36622
|
name: "deviceId",
|
|
36524
36623
|
form: "single",
|
|
@@ -36934,11 +37033,21 @@ Object.freeze({
|
|
|
36934
37033
|
form: "single",
|
|
36935
37034
|
optional: false
|
|
36936
37035
|
}],
|
|
37036
|
+
"recording.getAvailabilityBatch": [{
|
|
37037
|
+
name: "deviceIds",
|
|
37038
|
+
form: "array",
|
|
37039
|
+
optional: false
|
|
37040
|
+
}],
|
|
36937
37041
|
"recording.getDaysWithRecordings": [{
|
|
36938
37042
|
name: "deviceId",
|
|
36939
37043
|
form: "single",
|
|
36940
37044
|
optional: false
|
|
36941
37045
|
}],
|
|
37046
|
+
"recording.getDaysWithRecordingsBatch": [{
|
|
37047
|
+
name: "deviceIds",
|
|
37048
|
+
form: "array",
|
|
37049
|
+
optional: false
|
|
37050
|
+
}],
|
|
36942
37051
|
"recording.getDeviceConfig": [{
|
|
36943
37052
|
name: "deviceId",
|
|
36944
37053
|
form: "single",
|
|
@@ -19638,6 +19638,34 @@ var KeyEventsForDeviceSchema = object({
|
|
|
19638
19638
|
deviceId: number(),
|
|
19639
19639
|
events: array(KeyEventSchema).readonly()
|
|
19640
19640
|
});
|
|
19641
|
+
/** One non-empty bucket of the timeline histogram. */
|
|
19642
|
+
var EventDensityBucketSchema = object({
|
|
19643
|
+
bucketStart: number(),
|
|
19644
|
+
motion: number().int(),
|
|
19645
|
+
object: number().int(),
|
|
19646
|
+
audio: number().int()
|
|
19647
|
+
});
|
|
19648
|
+
/**
|
|
19649
|
+
* One camera's row in a `getEventDensityBatch` answer.
|
|
19650
|
+
*
|
|
19651
|
+
* TWO facts, and the timeline draws them differently:
|
|
19652
|
+
*
|
|
19653
|
+
* - `read: 'read'` — the histogram for this camera. `buckets: []` is a real
|
|
19654
|
+
* claim: read, and nothing happened in the window.
|
|
19655
|
+
* - `read: 'unreadable'` — nobody could answer for this camera. `buckets` is
|
|
19656
|
+
* empty and that emptiness means NOTHING; the timeline must render unknown,
|
|
19657
|
+
* not quiet.
|
|
19658
|
+
*
|
|
19659
|
+
* Fanned out per camera the difference was free — one query rejected while the
|
|
19660
|
+
* others resolved — and collapsing to a batch is the exact moment it is lost
|
|
19661
|
+
* silently. Every requested id gets a row: a caller that asked for twelve and
|
|
19662
|
+
* got eleven cannot tell which one is missing, or that any is.
|
|
19663
|
+
*/
|
|
19664
|
+
var EventDensityForDeviceSchema = object({
|
|
19665
|
+
deviceId: number(),
|
|
19666
|
+
read: _enum(["read", "unreadable"]),
|
|
19667
|
+
buckets: array(EventDensityBucketSchema).readonly()
|
|
19668
|
+
});
|
|
19641
19669
|
object({
|
|
19642
19670
|
trackId: string(),
|
|
19643
19671
|
className: string(),
|
|
@@ -19948,12 +19976,12 @@ DeviceType.Camera, method(object({ deviceId: number() }), array(TrackSchema).rea
|
|
|
19948
19976
|
since: number(),
|
|
19949
19977
|
until: number(),
|
|
19950
19978
|
bucketMs: number().int().positive()
|
|
19951
|
-
}), array(object({
|
|
19952
|
-
|
|
19953
|
-
|
|
19954
|
-
|
|
19955
|
-
|
|
19956
|
-
})).readonly()), method(object({
|
|
19979
|
+
}), array(EventDensityBucketSchema).readonly()), method(object({
|
|
19980
|
+
deviceIds: array(number()).min(1).max(200),
|
|
19981
|
+
since: number(),
|
|
19982
|
+
until: number(),
|
|
19983
|
+
bucketMs: number().int().positive()
|
|
19984
|
+
}), array(EventDensityForDeviceSchema).readonly()), method(object({
|
|
19957
19985
|
deviceId: number(),
|
|
19958
19986
|
cutoffMs: number()
|
|
19959
19987
|
}), object({
|
|
@@ -27311,6 +27339,39 @@ var RecordingDaysSchema = object({
|
|
|
27311
27339
|
/** Local-midnight epochs (UTC ms) of days that have ≥1 recorded segment. */
|
|
27312
27340
|
days: array(number())
|
|
27313
27341
|
});
|
|
27342
|
+
/**
|
|
27343
|
+
* One camera's row in a `getAvailabilityBatch` answer.
|
|
27344
|
+
*
|
|
27345
|
+
* `ranges` is EXACTLY what `getAvailability` returns for that camera — the
|
|
27346
|
+
* batch collapses the transport, not the work — plus the one thing the singular
|
|
27347
|
+
* method never had to say:
|
|
27348
|
+
*
|
|
27349
|
+
* - `read: 'read'` — answered. `ranges: []` means "read, and this camera has
|
|
27350
|
+
* no footage in the window", which is a real claim.
|
|
27351
|
+
* - `read: 'unreadable'` — the recorder could not answer for this camera (its
|
|
27352
|
+
* calendar rung threw, its location is unmounted). `ranges` is empty and
|
|
27353
|
+
* that emptiness means NOTHING.
|
|
27354
|
+
*
|
|
27355
|
+
* A timeline that renders the second as the first tells an operator there is no
|
|
27356
|
+
* footage when the truth is that nobody looked.
|
|
27357
|
+
*/
|
|
27358
|
+
var RecordingAvailabilityForDeviceSchema = object({
|
|
27359
|
+
deviceId: number(),
|
|
27360
|
+
read: _enum(["read", "unreadable"]),
|
|
27361
|
+
ranges: array(RecordingRangeSchema).readonly()
|
|
27362
|
+
});
|
|
27363
|
+
/**
|
|
27364
|
+
* One camera's row in a `getDaysWithRecordingsBatch` answer. Same rule as
|
|
27365
|
+
* {@link RecordingAvailabilityForDeviceSchema}: `days: []` on a `'read'` row is
|
|
27366
|
+
* "no footage in this month", `read: 'unreadable'` is "nobody could look", and
|
|
27367
|
+
* the date-picker's day dots must not spell them the same.
|
|
27368
|
+
*/
|
|
27369
|
+
var RecordingDaysForDeviceSchema = object({
|
|
27370
|
+
deviceId: number(),
|
|
27371
|
+
read: _enum(["read", "unreadable"]),
|
|
27372
|
+
/** Local-midnight epochs (UTC ms) of days that have ≥1 recorded segment. */
|
|
27373
|
+
days: array(number()).readonly()
|
|
27374
|
+
});
|
|
27314
27375
|
var RecordingManifestSchema = object({
|
|
27315
27376
|
deviceId: number(),
|
|
27316
27377
|
/** Local filesystem path to the master playlist; null when no recording exists for the requested range. */
|
|
@@ -27545,6 +27606,13 @@ method(object({
|
|
|
27545
27606
|
}), RecordingAvailabilitySchema, {
|
|
27546
27607
|
kind: "query",
|
|
27547
27608
|
auth: "protected"
|
|
27609
|
+
}), method(object({
|
|
27610
|
+
deviceIds: array(number()).min(1).max(200),
|
|
27611
|
+
fromMs: number(),
|
|
27612
|
+
toMs: number()
|
|
27613
|
+
}), array(RecordingAvailabilityForDeviceSchema).readonly(), {
|
|
27614
|
+
kind: "query",
|
|
27615
|
+
auth: "protected"
|
|
27548
27616
|
}), method(object({
|
|
27549
27617
|
deviceId: number(),
|
|
27550
27618
|
fromMs: number(),
|
|
@@ -27553,6 +27621,14 @@ method(object({
|
|
|
27553
27621
|
}), RecordingDaysSchema, {
|
|
27554
27622
|
kind: "query",
|
|
27555
27623
|
auth: "protected"
|
|
27624
|
+
}), method(object({
|
|
27625
|
+
deviceIds: array(number()).min(1).max(200),
|
|
27626
|
+
fromMs: number(),
|
|
27627
|
+
toMs: number(),
|
|
27628
|
+
tzOffsetMinutes: number()
|
|
27629
|
+
}), array(RecordingDaysForDeviceSchema).readonly(), {
|
|
27630
|
+
kind: "query",
|
|
27631
|
+
auth: "protected"
|
|
27556
27632
|
}), method(object({
|
|
27557
27633
|
deviceId: number(),
|
|
27558
27634
|
fromMs: number(),
|
|
@@ -32775,6 +32851,12 @@ Object.freeze({
|
|
|
32775
32851
|
addonId: null,
|
|
32776
32852
|
access: "view"
|
|
32777
32853
|
},
|
|
32854
|
+
"pipelineAnalytics.getEventDensityBatch": {
|
|
32855
|
+
capName: "pipeline-analytics",
|
|
32856
|
+
capScope: "device",
|
|
32857
|
+
addonId: null,
|
|
32858
|
+
access: "view"
|
|
32859
|
+
},
|
|
32778
32860
|
"pipelineAnalytics.getEventMedia": {
|
|
32779
32861
|
capName: "pipeline-analytics",
|
|
32780
32862
|
capScope: "device",
|
|
@@ -33897,12 +33979,24 @@ Object.freeze({
|
|
|
33897
33979
|
addonId: null,
|
|
33898
33980
|
access: "view"
|
|
33899
33981
|
},
|
|
33982
|
+
"recording.getAvailabilityBatch": {
|
|
33983
|
+
capName: "recording",
|
|
33984
|
+
capScope: "system",
|
|
33985
|
+
addonId: null,
|
|
33986
|
+
access: "view"
|
|
33987
|
+
},
|
|
33900
33988
|
"recording.getDaysWithRecordings": {
|
|
33901
33989
|
capName: "recording",
|
|
33902
33990
|
capScope: "system",
|
|
33903
33991
|
addonId: null,
|
|
33904
33992
|
access: "view"
|
|
33905
33993
|
},
|
|
33994
|
+
"recording.getDaysWithRecordingsBatch": {
|
|
33995
|
+
capName: "recording",
|
|
33996
|
+
capScope: "system",
|
|
33997
|
+
addonId: null,
|
|
33998
|
+
access: "view"
|
|
33999
|
+
},
|
|
33906
34000
|
"recording.getDeviceConfig": {
|
|
33907
34001
|
capName: "recording",
|
|
33908
34002
|
capScope: "system",
|
|
@@ -36507,6 +36601,11 @@ Object.freeze({
|
|
|
36507
36601
|
form: "single",
|
|
36508
36602
|
optional: false
|
|
36509
36603
|
}],
|
|
36604
|
+
"pipelineAnalytics.getEventDensityBatch": [{
|
|
36605
|
+
name: "deviceIds",
|
|
36606
|
+
form: "array",
|
|
36607
|
+
optional: false
|
|
36608
|
+
}],
|
|
36510
36609
|
"pipelineAnalytics.getEventMedia": [{
|
|
36511
36610
|
name: "deviceId",
|
|
36512
36611
|
form: "single",
|
|
@@ -36922,11 +37021,21 @@ Object.freeze({
|
|
|
36922
37021
|
form: "single",
|
|
36923
37022
|
optional: false
|
|
36924
37023
|
}],
|
|
37024
|
+
"recording.getAvailabilityBatch": [{
|
|
37025
|
+
name: "deviceIds",
|
|
37026
|
+
form: "array",
|
|
37027
|
+
optional: false
|
|
37028
|
+
}],
|
|
36925
37029
|
"recording.getDaysWithRecordings": [{
|
|
36926
37030
|
name: "deviceId",
|
|
36927
37031
|
form: "single",
|
|
36928
37032
|
optional: false
|
|
36929
37033
|
}],
|
|
37034
|
+
"recording.getDaysWithRecordingsBatch": [{
|
|
37035
|
+
name: "deviceIds",
|
|
37036
|
+
form: "array",
|
|
37037
|
+
optional: false
|
|
37038
|
+
}],
|
|
36930
37039
|
"recording.getDeviceConfig": [{
|
|
36931
37040
|
name: "deviceId",
|
|
36932
37041
|
form: "single",
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@camstack/addon-export-hap",
|
|
3
|
-
"version": "1.2.
|
|
3
|
+
"version": "1.2.63",
|
|
4
4
|
"description": "HomeKit (HAP) exporter for CamStack devices. Publishes each exposed device as its own HomeKit accessory: cameras and doorbells with SRTP streaming, HomeKit Secure Video, motion, two-way audio, PTZ and battery; switches, lights, locks and sensors through a capability→service table.",
|
|
5
5
|
"keywords": [
|
|
6
6
|
"camstack",
|