@camstack/addon-export-google 0.1.14 → 0.1.16
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/export-google.addon.js +117 -6
- package/dist/export-google.addon.mjs +117 -6
- package/package.json +1 -1
|
@@ -15839,6 +15839,8 @@ var NcSystemEventKindSchema = _enum([
|
|
|
15839
15839
|
"device-offline",
|
|
15840
15840
|
"device-disabled",
|
|
15841
15841
|
"device-enabled",
|
|
15842
|
+
"device-battery-low",
|
|
15843
|
+
"device-battery-normal",
|
|
15842
15844
|
"stream-online",
|
|
15843
15845
|
"stream-offline",
|
|
15844
15846
|
"node-online",
|
|
@@ -19129,6 +19131,34 @@ var KeyEventsForDeviceSchema = object({
|
|
|
19129
19131
|
deviceId: number(),
|
|
19130
19132
|
events: array(KeyEventSchema).readonly()
|
|
19131
19133
|
});
|
|
19134
|
+
/** One non-empty bucket of the timeline histogram. */
|
|
19135
|
+
var EventDensityBucketSchema = object({
|
|
19136
|
+
bucketStart: number(),
|
|
19137
|
+
motion: number().int(),
|
|
19138
|
+
object: number().int(),
|
|
19139
|
+
audio: number().int()
|
|
19140
|
+
});
|
|
19141
|
+
/**
|
|
19142
|
+
* One camera's row in a `getEventDensityBatch` answer.
|
|
19143
|
+
*
|
|
19144
|
+
* TWO facts, and the timeline draws them differently:
|
|
19145
|
+
*
|
|
19146
|
+
* - `read: 'read'` — the histogram for this camera. `buckets: []` is a real
|
|
19147
|
+
* claim: read, and nothing happened in the window.
|
|
19148
|
+
* - `read: 'unreadable'` — nobody could answer for this camera. `buckets` is
|
|
19149
|
+
* empty and that emptiness means NOTHING; the timeline must render unknown,
|
|
19150
|
+
* not quiet.
|
|
19151
|
+
*
|
|
19152
|
+
* Fanned out per camera the difference was free — one query rejected while the
|
|
19153
|
+
* others resolved — and collapsing to a batch is the exact moment it is lost
|
|
19154
|
+
* silently. Every requested id gets a row: a caller that asked for twelve and
|
|
19155
|
+
* got eleven cannot tell which one is missing, or that any is.
|
|
19156
|
+
*/
|
|
19157
|
+
var EventDensityForDeviceSchema = object({
|
|
19158
|
+
deviceId: number(),
|
|
19159
|
+
read: _enum(["read", "unreadable"]),
|
|
19160
|
+
buckets: array(EventDensityBucketSchema).readonly()
|
|
19161
|
+
});
|
|
19132
19162
|
object({
|
|
19133
19163
|
trackId: string(),
|
|
19134
19164
|
className: string(),
|
|
@@ -19439,12 +19469,12 @@ DeviceType.Camera, method(object({ deviceId: number() }), array(TrackSchema).rea
|
|
|
19439
19469
|
since: number(),
|
|
19440
19470
|
until: number(),
|
|
19441
19471
|
bucketMs: number().int().positive()
|
|
19442
|
-
}), array(object({
|
|
19443
|
-
|
|
19444
|
-
|
|
19445
|
-
|
|
19446
|
-
|
|
19447
|
-
})).readonly()), method(object({
|
|
19472
|
+
}), array(EventDensityBucketSchema).readonly()), method(object({
|
|
19473
|
+
deviceIds: array(number()).min(1).max(200),
|
|
19474
|
+
since: number(),
|
|
19475
|
+
until: number(),
|
|
19476
|
+
bucketMs: number().int().positive()
|
|
19477
|
+
}), array(EventDensityForDeviceSchema).readonly()), method(object({
|
|
19448
19478
|
deviceId: number(),
|
|
19449
19479
|
cutoffMs: number()
|
|
19450
19480
|
}), object({
|
|
@@ -26766,6 +26796,39 @@ var RecordingDaysSchema = object({
|
|
|
26766
26796
|
/** Local-midnight epochs (UTC ms) of days that have ≥1 recorded segment. */
|
|
26767
26797
|
days: array(number())
|
|
26768
26798
|
});
|
|
26799
|
+
/**
|
|
26800
|
+
* One camera's row in a `getAvailabilityBatch` answer.
|
|
26801
|
+
*
|
|
26802
|
+
* `ranges` is EXACTLY what `getAvailability` returns for that camera — the
|
|
26803
|
+
* batch collapses the transport, not the work — plus the one thing the singular
|
|
26804
|
+
* method never had to say:
|
|
26805
|
+
*
|
|
26806
|
+
* - `read: 'read'` — answered. `ranges: []` means "read, and this camera has
|
|
26807
|
+
* no footage in the window", which is a real claim.
|
|
26808
|
+
* - `read: 'unreadable'` — the recorder could not answer for this camera (its
|
|
26809
|
+
* calendar rung threw, its location is unmounted). `ranges` is empty and
|
|
26810
|
+
* that emptiness means NOTHING.
|
|
26811
|
+
*
|
|
26812
|
+
* A timeline that renders the second as the first tells an operator there is no
|
|
26813
|
+
* footage when the truth is that nobody looked.
|
|
26814
|
+
*/
|
|
26815
|
+
var RecordingAvailabilityForDeviceSchema = object({
|
|
26816
|
+
deviceId: number(),
|
|
26817
|
+
read: _enum(["read", "unreadable"]),
|
|
26818
|
+
ranges: array(RecordingRangeSchema).readonly()
|
|
26819
|
+
});
|
|
26820
|
+
/**
|
|
26821
|
+
* One camera's row in a `getDaysWithRecordingsBatch` answer. Same rule as
|
|
26822
|
+
* {@link RecordingAvailabilityForDeviceSchema}: `days: []` on a `'read'` row is
|
|
26823
|
+
* "no footage in this month", `read: 'unreadable'` is "nobody could look", and
|
|
26824
|
+
* the date-picker's day dots must not spell them the same.
|
|
26825
|
+
*/
|
|
26826
|
+
var RecordingDaysForDeviceSchema = object({
|
|
26827
|
+
deviceId: number(),
|
|
26828
|
+
read: _enum(["read", "unreadable"]),
|
|
26829
|
+
/** Local-midnight epochs (UTC ms) of days that have ≥1 recorded segment. */
|
|
26830
|
+
days: array(number()).readonly()
|
|
26831
|
+
});
|
|
26769
26832
|
var RecordingManifestSchema = object({
|
|
26770
26833
|
deviceId: number(),
|
|
26771
26834
|
/** Local filesystem path to the master playlist; null when no recording exists for the requested range. */
|
|
@@ -27000,6 +27063,13 @@ method(object({
|
|
|
27000
27063
|
}), RecordingAvailabilitySchema, {
|
|
27001
27064
|
kind: "query",
|
|
27002
27065
|
auth: "protected"
|
|
27066
|
+
}), method(object({
|
|
27067
|
+
deviceIds: array(number()).min(1).max(200),
|
|
27068
|
+
fromMs: number(),
|
|
27069
|
+
toMs: number()
|
|
27070
|
+
}), array(RecordingAvailabilityForDeviceSchema).readonly(), {
|
|
27071
|
+
kind: "query",
|
|
27072
|
+
auth: "protected"
|
|
27003
27073
|
}), method(object({
|
|
27004
27074
|
deviceId: number(),
|
|
27005
27075
|
fromMs: number(),
|
|
@@ -27008,6 +27078,14 @@ method(object({
|
|
|
27008
27078
|
}), RecordingDaysSchema, {
|
|
27009
27079
|
kind: "query",
|
|
27010
27080
|
auth: "protected"
|
|
27081
|
+
}), method(object({
|
|
27082
|
+
deviceIds: array(number()).min(1).max(200),
|
|
27083
|
+
fromMs: number(),
|
|
27084
|
+
toMs: number(),
|
|
27085
|
+
tzOffsetMinutes: number()
|
|
27086
|
+
}), array(RecordingDaysForDeviceSchema).readonly(), {
|
|
27087
|
+
kind: "query",
|
|
27088
|
+
auth: "protected"
|
|
27011
27089
|
}), method(object({
|
|
27012
27090
|
deviceId: number(),
|
|
27013
27091
|
fromMs: number(),
|
|
@@ -32212,6 +32290,12 @@ Object.freeze({
|
|
|
32212
32290
|
addonId: null,
|
|
32213
32291
|
access: "view"
|
|
32214
32292
|
},
|
|
32293
|
+
"pipelineAnalytics.getEventDensityBatch": {
|
|
32294
|
+
capName: "pipeline-analytics",
|
|
32295
|
+
capScope: "device",
|
|
32296
|
+
addonId: null,
|
|
32297
|
+
access: "view"
|
|
32298
|
+
},
|
|
32215
32299
|
"pipelineAnalytics.getEventMedia": {
|
|
32216
32300
|
capName: "pipeline-analytics",
|
|
32217
32301
|
capScope: "device",
|
|
@@ -33334,12 +33418,24 @@ Object.freeze({
|
|
|
33334
33418
|
addonId: null,
|
|
33335
33419
|
access: "view"
|
|
33336
33420
|
},
|
|
33421
|
+
"recording.getAvailabilityBatch": {
|
|
33422
|
+
capName: "recording",
|
|
33423
|
+
capScope: "system",
|
|
33424
|
+
addonId: null,
|
|
33425
|
+
access: "view"
|
|
33426
|
+
},
|
|
33337
33427
|
"recording.getDaysWithRecordings": {
|
|
33338
33428
|
capName: "recording",
|
|
33339
33429
|
capScope: "system",
|
|
33340
33430
|
addonId: null,
|
|
33341
33431
|
access: "view"
|
|
33342
33432
|
},
|
|
33433
|
+
"recording.getDaysWithRecordingsBatch": {
|
|
33434
|
+
capName: "recording",
|
|
33435
|
+
capScope: "system",
|
|
33436
|
+
addonId: null,
|
|
33437
|
+
access: "view"
|
|
33438
|
+
},
|
|
33343
33439
|
"recording.getDeviceConfig": {
|
|
33344
33440
|
capName: "recording",
|
|
33345
33441
|
capScope: "system",
|
|
@@ -35944,6 +36040,11 @@ Object.freeze({
|
|
|
35944
36040
|
form: "single",
|
|
35945
36041
|
optional: false
|
|
35946
36042
|
}],
|
|
36043
|
+
"pipelineAnalytics.getEventDensityBatch": [{
|
|
36044
|
+
name: "deviceIds",
|
|
36045
|
+
form: "array",
|
|
36046
|
+
optional: false
|
|
36047
|
+
}],
|
|
35947
36048
|
"pipelineAnalytics.getEventMedia": [{
|
|
35948
36049
|
name: "deviceId",
|
|
35949
36050
|
form: "single",
|
|
@@ -36359,11 +36460,21 @@ Object.freeze({
|
|
|
36359
36460
|
form: "single",
|
|
36360
36461
|
optional: false
|
|
36361
36462
|
}],
|
|
36463
|
+
"recording.getAvailabilityBatch": [{
|
|
36464
|
+
name: "deviceIds",
|
|
36465
|
+
form: "array",
|
|
36466
|
+
optional: false
|
|
36467
|
+
}],
|
|
36362
36468
|
"recording.getDaysWithRecordings": [{
|
|
36363
36469
|
name: "deviceId",
|
|
36364
36470
|
form: "single",
|
|
36365
36471
|
optional: false
|
|
36366
36472
|
}],
|
|
36473
|
+
"recording.getDaysWithRecordingsBatch": [{
|
|
36474
|
+
name: "deviceIds",
|
|
36475
|
+
form: "array",
|
|
36476
|
+
optional: false
|
|
36477
|
+
}],
|
|
36367
36478
|
"recording.getDeviceConfig": [{
|
|
36368
36479
|
name: "deviceId",
|
|
36369
36480
|
form: "single",
|
|
@@ -15835,6 +15835,8 @@ var NcSystemEventKindSchema = _enum([
|
|
|
15835
15835
|
"device-offline",
|
|
15836
15836
|
"device-disabled",
|
|
15837
15837
|
"device-enabled",
|
|
15838
|
+
"device-battery-low",
|
|
15839
|
+
"device-battery-normal",
|
|
15838
15840
|
"stream-online",
|
|
15839
15841
|
"stream-offline",
|
|
15840
15842
|
"node-online",
|
|
@@ -19125,6 +19127,34 @@ var KeyEventsForDeviceSchema = object({
|
|
|
19125
19127
|
deviceId: number(),
|
|
19126
19128
|
events: array(KeyEventSchema).readonly()
|
|
19127
19129
|
});
|
|
19130
|
+
/** One non-empty bucket of the timeline histogram. */
|
|
19131
|
+
var EventDensityBucketSchema = object({
|
|
19132
|
+
bucketStart: number(),
|
|
19133
|
+
motion: number().int(),
|
|
19134
|
+
object: number().int(),
|
|
19135
|
+
audio: number().int()
|
|
19136
|
+
});
|
|
19137
|
+
/**
|
|
19138
|
+
* One camera's row in a `getEventDensityBatch` answer.
|
|
19139
|
+
*
|
|
19140
|
+
* TWO facts, and the timeline draws them differently:
|
|
19141
|
+
*
|
|
19142
|
+
* - `read: 'read'` — the histogram for this camera. `buckets: []` is a real
|
|
19143
|
+
* claim: read, and nothing happened in the window.
|
|
19144
|
+
* - `read: 'unreadable'` — nobody could answer for this camera. `buckets` is
|
|
19145
|
+
* empty and that emptiness means NOTHING; the timeline must render unknown,
|
|
19146
|
+
* not quiet.
|
|
19147
|
+
*
|
|
19148
|
+
* Fanned out per camera the difference was free — one query rejected while the
|
|
19149
|
+
* others resolved — and collapsing to a batch is the exact moment it is lost
|
|
19150
|
+
* silently. Every requested id gets a row: a caller that asked for twelve and
|
|
19151
|
+
* got eleven cannot tell which one is missing, or that any is.
|
|
19152
|
+
*/
|
|
19153
|
+
var EventDensityForDeviceSchema = object({
|
|
19154
|
+
deviceId: number(),
|
|
19155
|
+
read: _enum(["read", "unreadable"]),
|
|
19156
|
+
buckets: array(EventDensityBucketSchema).readonly()
|
|
19157
|
+
});
|
|
19128
19158
|
object({
|
|
19129
19159
|
trackId: string(),
|
|
19130
19160
|
className: string(),
|
|
@@ -19435,12 +19465,12 @@ DeviceType.Camera, method(object({ deviceId: number() }), array(TrackSchema).rea
|
|
|
19435
19465
|
since: number(),
|
|
19436
19466
|
until: number(),
|
|
19437
19467
|
bucketMs: number().int().positive()
|
|
19438
|
-
}), array(object({
|
|
19439
|
-
|
|
19440
|
-
|
|
19441
|
-
|
|
19442
|
-
|
|
19443
|
-
})).readonly()), method(object({
|
|
19468
|
+
}), array(EventDensityBucketSchema).readonly()), method(object({
|
|
19469
|
+
deviceIds: array(number()).min(1).max(200),
|
|
19470
|
+
since: number(),
|
|
19471
|
+
until: number(),
|
|
19472
|
+
bucketMs: number().int().positive()
|
|
19473
|
+
}), array(EventDensityForDeviceSchema).readonly()), method(object({
|
|
19444
19474
|
deviceId: number(),
|
|
19445
19475
|
cutoffMs: number()
|
|
19446
19476
|
}), object({
|
|
@@ -26762,6 +26792,39 @@ var RecordingDaysSchema = object({
|
|
|
26762
26792
|
/** Local-midnight epochs (UTC ms) of days that have ≥1 recorded segment. */
|
|
26763
26793
|
days: array(number())
|
|
26764
26794
|
});
|
|
26795
|
+
/**
|
|
26796
|
+
* One camera's row in a `getAvailabilityBatch` answer.
|
|
26797
|
+
*
|
|
26798
|
+
* `ranges` is EXACTLY what `getAvailability` returns for that camera — the
|
|
26799
|
+
* batch collapses the transport, not the work — plus the one thing the singular
|
|
26800
|
+
* method never had to say:
|
|
26801
|
+
*
|
|
26802
|
+
* - `read: 'read'` — answered. `ranges: []` means "read, and this camera has
|
|
26803
|
+
* no footage in the window", which is a real claim.
|
|
26804
|
+
* - `read: 'unreadable'` — the recorder could not answer for this camera (its
|
|
26805
|
+
* calendar rung threw, its location is unmounted). `ranges` is empty and
|
|
26806
|
+
* that emptiness means NOTHING.
|
|
26807
|
+
*
|
|
26808
|
+
* A timeline that renders the second as the first tells an operator there is no
|
|
26809
|
+
* footage when the truth is that nobody looked.
|
|
26810
|
+
*/
|
|
26811
|
+
var RecordingAvailabilityForDeviceSchema = object({
|
|
26812
|
+
deviceId: number(),
|
|
26813
|
+
read: _enum(["read", "unreadable"]),
|
|
26814
|
+
ranges: array(RecordingRangeSchema).readonly()
|
|
26815
|
+
});
|
|
26816
|
+
/**
|
|
26817
|
+
* One camera's row in a `getDaysWithRecordingsBatch` answer. Same rule as
|
|
26818
|
+
* {@link RecordingAvailabilityForDeviceSchema}: `days: []` on a `'read'` row is
|
|
26819
|
+
* "no footage in this month", `read: 'unreadable'` is "nobody could look", and
|
|
26820
|
+
* the date-picker's day dots must not spell them the same.
|
|
26821
|
+
*/
|
|
26822
|
+
var RecordingDaysForDeviceSchema = object({
|
|
26823
|
+
deviceId: number(),
|
|
26824
|
+
read: _enum(["read", "unreadable"]),
|
|
26825
|
+
/** Local-midnight epochs (UTC ms) of days that have ≥1 recorded segment. */
|
|
26826
|
+
days: array(number()).readonly()
|
|
26827
|
+
});
|
|
26765
26828
|
var RecordingManifestSchema = object({
|
|
26766
26829
|
deviceId: number(),
|
|
26767
26830
|
/** Local filesystem path to the master playlist; null when no recording exists for the requested range. */
|
|
@@ -26996,6 +27059,13 @@ method(object({
|
|
|
26996
27059
|
}), RecordingAvailabilitySchema, {
|
|
26997
27060
|
kind: "query",
|
|
26998
27061
|
auth: "protected"
|
|
27062
|
+
}), method(object({
|
|
27063
|
+
deviceIds: array(number()).min(1).max(200),
|
|
27064
|
+
fromMs: number(),
|
|
27065
|
+
toMs: number()
|
|
27066
|
+
}), array(RecordingAvailabilityForDeviceSchema).readonly(), {
|
|
27067
|
+
kind: "query",
|
|
27068
|
+
auth: "protected"
|
|
26999
27069
|
}), method(object({
|
|
27000
27070
|
deviceId: number(),
|
|
27001
27071
|
fromMs: number(),
|
|
@@ -27004,6 +27074,14 @@ method(object({
|
|
|
27004
27074
|
}), RecordingDaysSchema, {
|
|
27005
27075
|
kind: "query",
|
|
27006
27076
|
auth: "protected"
|
|
27077
|
+
}), method(object({
|
|
27078
|
+
deviceIds: array(number()).min(1).max(200),
|
|
27079
|
+
fromMs: number(),
|
|
27080
|
+
toMs: number(),
|
|
27081
|
+
tzOffsetMinutes: number()
|
|
27082
|
+
}), array(RecordingDaysForDeviceSchema).readonly(), {
|
|
27083
|
+
kind: "query",
|
|
27084
|
+
auth: "protected"
|
|
27007
27085
|
}), method(object({
|
|
27008
27086
|
deviceId: number(),
|
|
27009
27087
|
fromMs: number(),
|
|
@@ -32208,6 +32286,12 @@ Object.freeze({
|
|
|
32208
32286
|
addonId: null,
|
|
32209
32287
|
access: "view"
|
|
32210
32288
|
},
|
|
32289
|
+
"pipelineAnalytics.getEventDensityBatch": {
|
|
32290
|
+
capName: "pipeline-analytics",
|
|
32291
|
+
capScope: "device",
|
|
32292
|
+
addonId: null,
|
|
32293
|
+
access: "view"
|
|
32294
|
+
},
|
|
32211
32295
|
"pipelineAnalytics.getEventMedia": {
|
|
32212
32296
|
capName: "pipeline-analytics",
|
|
32213
32297
|
capScope: "device",
|
|
@@ -33330,12 +33414,24 @@ Object.freeze({
|
|
|
33330
33414
|
addonId: null,
|
|
33331
33415
|
access: "view"
|
|
33332
33416
|
},
|
|
33417
|
+
"recording.getAvailabilityBatch": {
|
|
33418
|
+
capName: "recording",
|
|
33419
|
+
capScope: "system",
|
|
33420
|
+
addonId: null,
|
|
33421
|
+
access: "view"
|
|
33422
|
+
},
|
|
33333
33423
|
"recording.getDaysWithRecordings": {
|
|
33334
33424
|
capName: "recording",
|
|
33335
33425
|
capScope: "system",
|
|
33336
33426
|
addonId: null,
|
|
33337
33427
|
access: "view"
|
|
33338
33428
|
},
|
|
33429
|
+
"recording.getDaysWithRecordingsBatch": {
|
|
33430
|
+
capName: "recording",
|
|
33431
|
+
capScope: "system",
|
|
33432
|
+
addonId: null,
|
|
33433
|
+
access: "view"
|
|
33434
|
+
},
|
|
33339
33435
|
"recording.getDeviceConfig": {
|
|
33340
33436
|
capName: "recording",
|
|
33341
33437
|
capScope: "system",
|
|
@@ -35940,6 +36036,11 @@ Object.freeze({
|
|
|
35940
36036
|
form: "single",
|
|
35941
36037
|
optional: false
|
|
35942
36038
|
}],
|
|
36039
|
+
"pipelineAnalytics.getEventDensityBatch": [{
|
|
36040
|
+
name: "deviceIds",
|
|
36041
|
+
form: "array",
|
|
36042
|
+
optional: false
|
|
36043
|
+
}],
|
|
35943
36044
|
"pipelineAnalytics.getEventMedia": [{
|
|
35944
36045
|
name: "deviceId",
|
|
35945
36046
|
form: "single",
|
|
@@ -36355,11 +36456,21 @@ Object.freeze({
|
|
|
36355
36456
|
form: "single",
|
|
36356
36457
|
optional: false
|
|
36357
36458
|
}],
|
|
36459
|
+
"recording.getAvailabilityBatch": [{
|
|
36460
|
+
name: "deviceIds",
|
|
36461
|
+
form: "array",
|
|
36462
|
+
optional: false
|
|
36463
|
+
}],
|
|
36358
36464
|
"recording.getDaysWithRecordings": [{
|
|
36359
36465
|
name: "deviceId",
|
|
36360
36466
|
form: "single",
|
|
36361
36467
|
optional: false
|
|
36362
36468
|
}],
|
|
36469
|
+
"recording.getDaysWithRecordingsBatch": [{
|
|
36470
|
+
name: "deviceIds",
|
|
36471
|
+
form: "array",
|
|
36472
|
+
optional: false
|
|
36473
|
+
}],
|
|
36363
36474
|
"recording.getDeviceConfig": [{
|
|
36364
36475
|
name: "deviceId",
|
|
36365
36476
|
form: "single",
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@camstack/addon-export-google",
|
|
3
|
-
"version": "0.1.
|
|
3
|
+
"version": "0.1.16",
|
|
4
4
|
"description": "Google Home export — hub-side smart-home fulfillment (SYNC / QUERY / EXECUTE / DISCONNECT) for the non-camera fleet, served over the hub's own OAuth account link. No Google credential is stored, sent or required.",
|
|
5
5
|
"keywords": [
|
|
6
6
|
"camstack",
|