@camstack/addon-export-google 0.1.15 → 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 +115 -6
- package/dist/export-google.addon.mjs +115 -6
- package/package.json +1 -1
|
@@ -19131,6 +19131,34 @@ var KeyEventsForDeviceSchema = object({
|
|
|
19131
19131
|
deviceId: number(),
|
|
19132
19132
|
events: array(KeyEventSchema).readonly()
|
|
19133
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
|
+
});
|
|
19134
19162
|
object({
|
|
19135
19163
|
trackId: string(),
|
|
19136
19164
|
className: string(),
|
|
@@ -19441,12 +19469,12 @@ DeviceType.Camera, method(object({ deviceId: number() }), array(TrackSchema).rea
|
|
|
19441
19469
|
since: number(),
|
|
19442
19470
|
until: number(),
|
|
19443
19471
|
bucketMs: number().int().positive()
|
|
19444
|
-
}), array(object({
|
|
19445
|
-
|
|
19446
|
-
|
|
19447
|
-
|
|
19448
|
-
|
|
19449
|
-
})).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({
|
|
19450
19478
|
deviceId: number(),
|
|
19451
19479
|
cutoffMs: number()
|
|
19452
19480
|
}), object({
|
|
@@ -26768,6 +26796,39 @@ var RecordingDaysSchema = object({
|
|
|
26768
26796
|
/** Local-midnight epochs (UTC ms) of days that have ≥1 recorded segment. */
|
|
26769
26797
|
days: array(number())
|
|
26770
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
|
+
});
|
|
26771
26832
|
var RecordingManifestSchema = object({
|
|
26772
26833
|
deviceId: number(),
|
|
26773
26834
|
/** Local filesystem path to the master playlist; null when no recording exists for the requested range. */
|
|
@@ -27002,6 +27063,13 @@ method(object({
|
|
|
27002
27063
|
}), RecordingAvailabilitySchema, {
|
|
27003
27064
|
kind: "query",
|
|
27004
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"
|
|
27005
27073
|
}), method(object({
|
|
27006
27074
|
deviceId: number(),
|
|
27007
27075
|
fromMs: number(),
|
|
@@ -27010,6 +27078,14 @@ method(object({
|
|
|
27010
27078
|
}), RecordingDaysSchema, {
|
|
27011
27079
|
kind: "query",
|
|
27012
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"
|
|
27013
27089
|
}), method(object({
|
|
27014
27090
|
deviceId: number(),
|
|
27015
27091
|
fromMs: number(),
|
|
@@ -32214,6 +32290,12 @@ Object.freeze({
|
|
|
32214
32290
|
addonId: null,
|
|
32215
32291
|
access: "view"
|
|
32216
32292
|
},
|
|
32293
|
+
"pipelineAnalytics.getEventDensityBatch": {
|
|
32294
|
+
capName: "pipeline-analytics",
|
|
32295
|
+
capScope: "device",
|
|
32296
|
+
addonId: null,
|
|
32297
|
+
access: "view"
|
|
32298
|
+
},
|
|
32217
32299
|
"pipelineAnalytics.getEventMedia": {
|
|
32218
32300
|
capName: "pipeline-analytics",
|
|
32219
32301
|
capScope: "device",
|
|
@@ -33336,12 +33418,24 @@ Object.freeze({
|
|
|
33336
33418
|
addonId: null,
|
|
33337
33419
|
access: "view"
|
|
33338
33420
|
},
|
|
33421
|
+
"recording.getAvailabilityBatch": {
|
|
33422
|
+
capName: "recording",
|
|
33423
|
+
capScope: "system",
|
|
33424
|
+
addonId: null,
|
|
33425
|
+
access: "view"
|
|
33426
|
+
},
|
|
33339
33427
|
"recording.getDaysWithRecordings": {
|
|
33340
33428
|
capName: "recording",
|
|
33341
33429
|
capScope: "system",
|
|
33342
33430
|
addonId: null,
|
|
33343
33431
|
access: "view"
|
|
33344
33432
|
},
|
|
33433
|
+
"recording.getDaysWithRecordingsBatch": {
|
|
33434
|
+
capName: "recording",
|
|
33435
|
+
capScope: "system",
|
|
33436
|
+
addonId: null,
|
|
33437
|
+
access: "view"
|
|
33438
|
+
},
|
|
33345
33439
|
"recording.getDeviceConfig": {
|
|
33346
33440
|
capName: "recording",
|
|
33347
33441
|
capScope: "system",
|
|
@@ -35946,6 +36040,11 @@ Object.freeze({
|
|
|
35946
36040
|
form: "single",
|
|
35947
36041
|
optional: false
|
|
35948
36042
|
}],
|
|
36043
|
+
"pipelineAnalytics.getEventDensityBatch": [{
|
|
36044
|
+
name: "deviceIds",
|
|
36045
|
+
form: "array",
|
|
36046
|
+
optional: false
|
|
36047
|
+
}],
|
|
35949
36048
|
"pipelineAnalytics.getEventMedia": [{
|
|
35950
36049
|
name: "deviceId",
|
|
35951
36050
|
form: "single",
|
|
@@ -36361,11 +36460,21 @@ Object.freeze({
|
|
|
36361
36460
|
form: "single",
|
|
36362
36461
|
optional: false
|
|
36363
36462
|
}],
|
|
36463
|
+
"recording.getAvailabilityBatch": [{
|
|
36464
|
+
name: "deviceIds",
|
|
36465
|
+
form: "array",
|
|
36466
|
+
optional: false
|
|
36467
|
+
}],
|
|
36364
36468
|
"recording.getDaysWithRecordings": [{
|
|
36365
36469
|
name: "deviceId",
|
|
36366
36470
|
form: "single",
|
|
36367
36471
|
optional: false
|
|
36368
36472
|
}],
|
|
36473
|
+
"recording.getDaysWithRecordingsBatch": [{
|
|
36474
|
+
name: "deviceIds",
|
|
36475
|
+
form: "array",
|
|
36476
|
+
optional: false
|
|
36477
|
+
}],
|
|
36369
36478
|
"recording.getDeviceConfig": [{
|
|
36370
36479
|
name: "deviceId",
|
|
36371
36480
|
form: "single",
|
|
@@ -19127,6 +19127,34 @@ var KeyEventsForDeviceSchema = object({
|
|
|
19127
19127
|
deviceId: number(),
|
|
19128
19128
|
events: array(KeyEventSchema).readonly()
|
|
19129
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
|
+
});
|
|
19130
19158
|
object({
|
|
19131
19159
|
trackId: string(),
|
|
19132
19160
|
className: string(),
|
|
@@ -19437,12 +19465,12 @@ DeviceType.Camera, method(object({ deviceId: number() }), array(TrackSchema).rea
|
|
|
19437
19465
|
since: number(),
|
|
19438
19466
|
until: number(),
|
|
19439
19467
|
bucketMs: number().int().positive()
|
|
19440
|
-
}), array(object({
|
|
19441
|
-
|
|
19442
|
-
|
|
19443
|
-
|
|
19444
|
-
|
|
19445
|
-
})).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({
|
|
19446
19474
|
deviceId: number(),
|
|
19447
19475
|
cutoffMs: number()
|
|
19448
19476
|
}), object({
|
|
@@ -26764,6 +26792,39 @@ var RecordingDaysSchema = object({
|
|
|
26764
26792
|
/** Local-midnight epochs (UTC ms) of days that have ≥1 recorded segment. */
|
|
26765
26793
|
days: array(number())
|
|
26766
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
|
+
});
|
|
26767
26828
|
var RecordingManifestSchema = object({
|
|
26768
26829
|
deviceId: number(),
|
|
26769
26830
|
/** Local filesystem path to the master playlist; null when no recording exists for the requested range. */
|
|
@@ -26998,6 +27059,13 @@ method(object({
|
|
|
26998
27059
|
}), RecordingAvailabilitySchema, {
|
|
26999
27060
|
kind: "query",
|
|
27000
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"
|
|
27001
27069
|
}), method(object({
|
|
27002
27070
|
deviceId: number(),
|
|
27003
27071
|
fromMs: number(),
|
|
@@ -27006,6 +27074,14 @@ method(object({
|
|
|
27006
27074
|
}), RecordingDaysSchema, {
|
|
27007
27075
|
kind: "query",
|
|
27008
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"
|
|
27009
27085
|
}), method(object({
|
|
27010
27086
|
deviceId: number(),
|
|
27011
27087
|
fromMs: number(),
|
|
@@ -32210,6 +32286,12 @@ Object.freeze({
|
|
|
32210
32286
|
addonId: null,
|
|
32211
32287
|
access: "view"
|
|
32212
32288
|
},
|
|
32289
|
+
"pipelineAnalytics.getEventDensityBatch": {
|
|
32290
|
+
capName: "pipeline-analytics",
|
|
32291
|
+
capScope: "device",
|
|
32292
|
+
addonId: null,
|
|
32293
|
+
access: "view"
|
|
32294
|
+
},
|
|
32213
32295
|
"pipelineAnalytics.getEventMedia": {
|
|
32214
32296
|
capName: "pipeline-analytics",
|
|
32215
32297
|
capScope: "device",
|
|
@@ -33332,12 +33414,24 @@ Object.freeze({
|
|
|
33332
33414
|
addonId: null,
|
|
33333
33415
|
access: "view"
|
|
33334
33416
|
},
|
|
33417
|
+
"recording.getAvailabilityBatch": {
|
|
33418
|
+
capName: "recording",
|
|
33419
|
+
capScope: "system",
|
|
33420
|
+
addonId: null,
|
|
33421
|
+
access: "view"
|
|
33422
|
+
},
|
|
33335
33423
|
"recording.getDaysWithRecordings": {
|
|
33336
33424
|
capName: "recording",
|
|
33337
33425
|
capScope: "system",
|
|
33338
33426
|
addonId: null,
|
|
33339
33427
|
access: "view"
|
|
33340
33428
|
},
|
|
33429
|
+
"recording.getDaysWithRecordingsBatch": {
|
|
33430
|
+
capName: "recording",
|
|
33431
|
+
capScope: "system",
|
|
33432
|
+
addonId: null,
|
|
33433
|
+
access: "view"
|
|
33434
|
+
},
|
|
33341
33435
|
"recording.getDeviceConfig": {
|
|
33342
33436
|
capName: "recording",
|
|
33343
33437
|
capScope: "system",
|
|
@@ -35942,6 +36036,11 @@ Object.freeze({
|
|
|
35942
36036
|
form: "single",
|
|
35943
36037
|
optional: false
|
|
35944
36038
|
}],
|
|
36039
|
+
"pipelineAnalytics.getEventDensityBatch": [{
|
|
36040
|
+
name: "deviceIds",
|
|
36041
|
+
form: "array",
|
|
36042
|
+
optional: false
|
|
36043
|
+
}],
|
|
35945
36044
|
"pipelineAnalytics.getEventMedia": [{
|
|
35946
36045
|
name: "deviceId",
|
|
35947
36046
|
form: "single",
|
|
@@ -36357,11 +36456,21 @@ Object.freeze({
|
|
|
36357
36456
|
form: "single",
|
|
36358
36457
|
optional: false
|
|
36359
36458
|
}],
|
|
36459
|
+
"recording.getAvailabilityBatch": [{
|
|
36460
|
+
name: "deviceIds",
|
|
36461
|
+
form: "array",
|
|
36462
|
+
optional: false
|
|
36463
|
+
}],
|
|
36360
36464
|
"recording.getDaysWithRecordings": [{
|
|
36361
36465
|
name: "deviceId",
|
|
36362
36466
|
form: "single",
|
|
36363
36467
|
optional: false
|
|
36364
36468
|
}],
|
|
36469
|
+
"recording.getDaysWithRecordingsBatch": [{
|
|
36470
|
+
name: "deviceIds",
|
|
36471
|
+
form: "array",
|
|
36472
|
+
optional: false
|
|
36473
|
+
}],
|
|
36365
36474
|
"recording.getDeviceConfig": [{
|
|
36366
36475
|
name: "deviceId",
|
|
36367
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",
|