camstreamerlib 4.0.0-beta.114 → 4.0.0-beta.116
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/cjs/CamStreamerAPI.d.ts +1155 -503
- package/cjs/CamStreamerAPI.js +4 -4
- package/cjs/VapixAPI.d.ts +1 -1
- package/cjs/errors/errors.d.ts +2 -2
- package/cjs/types/CamStreamerAPI/CamStreamerAPI.d.ts +8086 -2769
- package/cjs/types/CamStreamerAPI/CamStreamerAPI.js +39 -55
- package/cjs/types/CamStreamerAPI/facebookSchema.d.ts +183 -55
- package/cjs/types/CamStreamerAPI/facebookSchema.js +6 -10
- package/cjs/types/CamStreamerAPI/index.d.ts +1 -5
- package/cjs/types/CamStreamerAPI/index.js +1 -5
- package/cjs/types/CamStreamerAPI/oldStreamSchema.d.ts +39 -39
- package/cjs/types/CamStreamerAPI/oldStreamSchema.js +1 -1
- package/cjs/types/CamStreamerAPI/streamCommonTypes.d.ts +224 -341
- package/cjs/types/CamStreamerAPI/streamCommonTypes.js +89 -75
- package/cjs/types/CamStreamerAPI/streamsSchema.d.ts +7333 -0
- package/cjs/types/CamStreamerAPI/streamsSchema.js +63 -0
- package/cjs/types/CamStreamerAPI/windySchema.d.ts +159 -45
- package/cjs/types/CamStreamerAPI/windySchema.js +1 -1
- package/cjs/types/CamStreamerAPI/youtubeSchema.d.ts +159 -54
- package/cjs/types/CamStreamerAPI/youtubeSchema.js +1 -4
- package/cjs/types/VapixAPI.d.ts +10 -10
- package/cjs/types/ws/CamStreamerEvents.d.ts +33 -33
- package/cjs/types/ws/CamStreamerEvents.js +3 -3
- package/esm/CamStreamerAPI.js +4 -4
- package/esm/types/CamStreamerAPI/CamStreamerAPI.js +22 -38
- package/esm/types/CamStreamerAPI/facebookSchema.js +5 -9
- package/esm/types/CamStreamerAPI/index.js +1 -5
- package/esm/types/CamStreamerAPI/oldStreamSchema.js +1 -1
- package/esm/types/CamStreamerAPI/streamCommonTypes.js +88 -74
- package/esm/types/CamStreamerAPI/streamsSchema.js +57 -0
- package/esm/types/CamStreamerAPI/windySchema.js +1 -1
- package/esm/types/CamStreamerAPI/youtubeSchema.js +1 -4
- package/esm/types/ws/CamStreamerEvents.js +3 -3
- package/package.json +1 -1
- package/types/CamStreamerAPI.d.ts +1155 -503
- package/types/VapixAPI.d.ts +1 -1
- package/types/errors/errors.d.ts +2 -2
- package/types/types/CamStreamerAPI/CamStreamerAPI.d.ts +8086 -2769
- package/types/types/CamStreamerAPI/facebookSchema.d.ts +183 -55
- package/types/types/CamStreamerAPI/index.d.ts +1 -5
- package/types/types/CamStreamerAPI/oldStreamSchema.d.ts +39 -39
- package/types/types/CamStreamerAPI/streamCommonTypes.d.ts +224 -341
- package/types/types/CamStreamerAPI/streamsSchema.d.ts +7333 -0
- package/types/types/CamStreamerAPI/windySchema.d.ts +159 -45
- package/types/types/CamStreamerAPI/youtubeSchema.d.ts +159 -54
- package/types/types/VapixAPI.d.ts +10 -10
- package/types/types/ws/CamStreamerEvents.d.ts +33 -33
- package/cjs/types/CamStreamerAPI/churchSchema.d.ts +0 -293
- package/cjs/types/CamStreamerAPI/churchSchema.js +0 -11
- package/cjs/types/CamStreamerAPI/daCastSchema.d.ts +0 -293
- package/cjs/types/CamStreamerAPI/daCastSchema.js +0 -11
- package/cjs/types/CamStreamerAPI/dailymotionSchema.d.ts +0 -293
- package/cjs/types/CamStreamerAPI/dailymotionSchema.js +0 -11
- package/cjs/types/CamStreamerAPI/gameChangerSchema.d.ts +0 -312
- package/cjs/types/CamStreamerAPI/gameChangerSchema.js +0 -11
- package/cjs/types/CamStreamerAPI/hlsPullSchema.d.ts +0 -293
- package/cjs/types/CamStreamerAPI/hlsPullSchema.js +0 -11
- package/cjs/types/CamStreamerAPI/hlsPushSchema.d.ts +0 -293
- package/cjs/types/CamStreamerAPI/hlsPushSchema.js +0 -11
- package/cjs/types/CamStreamerAPI/ibmSchema.d.ts +0 -293
- package/cjs/types/CamStreamerAPI/ibmSchema.js +0 -11
- package/cjs/types/CamStreamerAPI/microsoftAzureSchema.d.ts +0 -293
- package/cjs/types/CamStreamerAPI/microsoftAzureSchema.js +0 -11
- package/cjs/types/CamStreamerAPI/microsoftStreamSchema.d.ts +0 -293
- package/cjs/types/CamStreamerAPI/microsoftStreamSchema.js +0 -11
- package/cjs/types/CamStreamerAPI/mpegDvbSchema.d.ts +0 -341
- package/cjs/types/CamStreamerAPI/mpegDvbSchema.js +0 -27
- package/cjs/types/CamStreamerAPI/rtmpSchema.d.ts +0 -619
- package/cjs/types/CamStreamerAPI/rtmpSchema.js +0 -19
- package/cjs/types/CamStreamerAPI/sdCardSchema.d.ts +0 -293
- package/cjs/types/CamStreamerAPI/sdCardSchema.js +0 -11
- package/cjs/types/CamStreamerAPI/srtSchema.d.ts +0 -293
- package/cjs/types/CamStreamerAPI/srtSchema.js +0 -11
- package/cjs/types/CamStreamerAPI/twitchSchema.d.ts +0 -293
- package/cjs/types/CamStreamerAPI/twitchSchema.js +0 -11
- package/cjs/types/CamStreamerAPI/vimeoSchema.d.ts +0 -293
- package/cjs/types/CamStreamerAPI/vimeoSchema.js +0 -11
- package/cjs/types/CamStreamerAPI/wowzaSchema.d.ts +0 -293
- package/cjs/types/CamStreamerAPI/wowzaSchema.js +0 -11
- package/cjs/types/CamStreamerAPI/youtubeRtmpSchema.d.ts +0 -312
- package/cjs/types/CamStreamerAPI/youtubeRtmpSchema.js +0 -11
- package/esm/types/CamStreamerAPI/churchSchema.js +0 -5
- package/esm/types/CamStreamerAPI/daCastSchema.js +0 -5
- package/esm/types/CamStreamerAPI/dailymotionSchema.js +0 -5
- package/esm/types/CamStreamerAPI/gameChangerSchema.js +0 -5
- package/esm/types/CamStreamerAPI/hlsPullSchema.js +0 -5
- package/esm/types/CamStreamerAPI/hlsPushSchema.js +0 -5
- package/esm/types/CamStreamerAPI/ibmSchema.js +0 -5
- package/esm/types/CamStreamerAPI/microsoftAzureSchema.js +0 -5
- package/esm/types/CamStreamerAPI/microsoftStreamSchema.js +0 -5
- package/esm/types/CamStreamerAPI/mpegDvbSchema.js +0 -21
- package/esm/types/CamStreamerAPI/rtmpSchema.js +0 -13
- package/esm/types/CamStreamerAPI/sdCardSchema.js +0 -5
- package/esm/types/CamStreamerAPI/srtSchema.js +0 -5
- package/esm/types/CamStreamerAPI/twitchSchema.js +0 -5
- package/esm/types/CamStreamerAPI/vimeoSchema.js +0 -5
- package/esm/types/CamStreamerAPI/wowzaSchema.js +0 -5
- package/esm/types/CamStreamerAPI/youtubeRtmpSchema.js +0 -5
- package/types/types/CamStreamerAPI/churchSchema.d.ts +0 -293
- package/types/types/CamStreamerAPI/daCastSchema.d.ts +0 -293
- package/types/types/CamStreamerAPI/dailymotionSchema.d.ts +0 -293
- package/types/types/CamStreamerAPI/gameChangerSchema.d.ts +0 -312
- package/types/types/CamStreamerAPI/hlsPullSchema.d.ts +0 -293
- package/types/types/CamStreamerAPI/hlsPushSchema.d.ts +0 -293
- package/types/types/CamStreamerAPI/ibmSchema.d.ts +0 -293
- package/types/types/CamStreamerAPI/microsoftAzureSchema.d.ts +0 -293
- package/types/types/CamStreamerAPI/microsoftStreamSchema.d.ts +0 -293
- package/types/types/CamStreamerAPI/mpegDvbSchema.d.ts +0 -341
- package/types/types/CamStreamerAPI/rtmpSchema.d.ts +0 -619
- package/types/types/CamStreamerAPI/sdCardSchema.d.ts +0 -293
- package/types/types/CamStreamerAPI/srtSchema.d.ts +0 -293
- package/types/types/CamStreamerAPI/twitchSchema.d.ts +0 -293
- package/types/types/CamStreamerAPI/vimeoSchema.d.ts +0 -293
- package/types/types/CamStreamerAPI/wowzaSchema.d.ts +0 -293
- package/types/types/CamStreamerAPI/youtubeRtmpSchema.d.ts +0 -312
package/cjs/CamStreamerAPI.d.ts
CHANGED
|
@@ -23,43 +23,60 @@ export declare class CamStreamerAPI<Client extends IClient<TResponse, any>> {
|
|
|
23
23
|
postLocation: "page";
|
|
24
24
|
page: string;
|
|
25
25
|
};
|
|
26
|
-
|
|
26
|
+
status: {
|
|
27
|
+
port: number | null;
|
|
28
|
+
led: boolean;
|
|
29
|
+
};
|
|
27
30
|
audio: {
|
|
28
|
-
source: "none";
|
|
29
|
-
} | {
|
|
30
31
|
source: "microphone";
|
|
31
32
|
audioChannelNbr: 1 | 2;
|
|
33
|
+
forceStereo: 0 | 1;
|
|
32
34
|
} | {
|
|
33
35
|
source: "file";
|
|
36
|
+
forceStereo: 0 | 1;
|
|
34
37
|
fileName: string;
|
|
35
38
|
filePath: string;
|
|
36
39
|
} | {
|
|
37
40
|
source: "url";
|
|
41
|
+
forceStereo: 0 | 1;
|
|
38
42
|
fileName: string;
|
|
39
43
|
fileUrl: string;
|
|
40
44
|
avSyncMsec: number;
|
|
41
|
-
};
|
|
45
|
+
} | null;
|
|
42
46
|
video: {
|
|
43
|
-
|
|
47
|
+
output: {
|
|
48
|
+
type: "video" | "images";
|
|
49
|
+
url: string;
|
|
50
|
+
callApi: false;
|
|
51
|
+
} | {
|
|
52
|
+
type: "video";
|
|
53
|
+
callApi: true;
|
|
54
|
+
prepareAheadS: number;
|
|
55
|
+
};
|
|
56
|
+
outputParameters: string;
|
|
57
|
+
input: {
|
|
58
|
+
type: "RTSP_URL";
|
|
59
|
+
url: string;
|
|
60
|
+
} | {
|
|
61
|
+
type: "CSw" | "CRS";
|
|
62
|
+
};
|
|
63
|
+
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
44
64
|
internalVapixParameters: string;
|
|
45
65
|
userVapixParameters: string;
|
|
46
|
-
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
47
|
-
sourceUrl?: string | undefined;
|
|
48
66
|
streamDelay?: {
|
|
49
67
|
value: number;
|
|
50
68
|
unit: "seconds" | "minutes" | "hours";
|
|
51
69
|
} | undefined;
|
|
52
70
|
};
|
|
53
71
|
enabled: boolean;
|
|
54
|
-
|
|
72
|
+
streamId: string;
|
|
55
73
|
active: boolean;
|
|
56
74
|
title: string;
|
|
57
75
|
trigger: {
|
|
58
76
|
type: "manual";
|
|
59
|
-
ioPort:
|
|
77
|
+
ioPort: number | null;
|
|
60
78
|
} | {
|
|
61
79
|
type: "onetime";
|
|
62
|
-
ioPort: string | null;
|
|
63
80
|
startTime: number;
|
|
64
81
|
stopTime: number;
|
|
65
82
|
} | {
|
|
@@ -76,51 +93,65 @@ export declare class CamStreamerAPI<Client extends IClient<TResponse, any>> {
|
|
|
76
93
|
isActive: boolean;
|
|
77
94
|
}[];
|
|
78
95
|
};
|
|
96
|
+
platform: "facebook";
|
|
79
97
|
deleteAfterEnd: boolean;
|
|
80
|
-
saveToSdCard: boolean;
|
|
81
|
-
statusCameraLed: boolean;
|
|
82
|
-
statusCameraOutput: string | null;
|
|
83
98
|
countdown: boolean;
|
|
84
99
|
description?: string | undefined;
|
|
85
100
|
} | {
|
|
86
|
-
|
|
101
|
+
status: {
|
|
102
|
+
port: number | null;
|
|
103
|
+
led: boolean;
|
|
104
|
+
};
|
|
87
105
|
audio: {
|
|
88
|
-
source: "none";
|
|
89
|
-
} | {
|
|
90
106
|
source: "microphone";
|
|
91
107
|
audioChannelNbr: 1 | 2;
|
|
108
|
+
forceStereo: 0 | 1;
|
|
92
109
|
} | {
|
|
93
110
|
source: "file";
|
|
111
|
+
forceStereo: 0 | 1;
|
|
94
112
|
fileName: string;
|
|
95
113
|
filePath: string;
|
|
96
114
|
} | {
|
|
97
115
|
source: "url";
|
|
116
|
+
forceStereo: 0 | 1;
|
|
98
117
|
fileName: string;
|
|
99
118
|
fileUrl: string;
|
|
100
119
|
avSyncMsec: number;
|
|
101
|
-
};
|
|
120
|
+
} | null;
|
|
102
121
|
video: {
|
|
103
|
-
|
|
122
|
+
output: {
|
|
123
|
+
type: "video" | "images";
|
|
124
|
+
url: string;
|
|
125
|
+
callApi: false;
|
|
126
|
+
} | {
|
|
127
|
+
type: "video";
|
|
128
|
+
callApi: true;
|
|
129
|
+
prepareAheadS: number;
|
|
130
|
+
};
|
|
131
|
+
outputParameters: string;
|
|
132
|
+
input: {
|
|
133
|
+
type: "RTSP_URL";
|
|
134
|
+
url: string;
|
|
135
|
+
} | {
|
|
136
|
+
type: "CSw" | "CRS";
|
|
137
|
+
};
|
|
138
|
+
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
104
139
|
internalVapixParameters: string;
|
|
105
140
|
userVapixParameters: string;
|
|
106
|
-
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
107
|
-
sourceUrl?: string | undefined;
|
|
108
141
|
streamDelay?: {
|
|
109
142
|
value: number;
|
|
110
143
|
unit: "seconds" | "minutes" | "hours";
|
|
111
144
|
} | undefined;
|
|
112
145
|
};
|
|
113
|
-
port: number;
|
|
114
146
|
enabled: boolean;
|
|
115
|
-
|
|
147
|
+
streamId: string;
|
|
116
148
|
active: boolean;
|
|
117
149
|
title: string;
|
|
118
150
|
trigger: {
|
|
119
151
|
type: "manual";
|
|
120
|
-
ioPort:
|
|
152
|
+
ioPort: number | null;
|
|
121
153
|
} | {
|
|
122
154
|
type: "onetime";
|
|
123
|
-
ioPort: string | null;
|
|
124
155
|
startTime: number;
|
|
125
156
|
stopTime: number;
|
|
126
157
|
} | {
|
|
@@ -137,59 +168,62 @@ export declare class CamStreamerAPI<Client extends IClient<TResponse, any>> {
|
|
|
137
168
|
isActive: boolean;
|
|
138
169
|
}[];
|
|
139
170
|
};
|
|
140
|
-
|
|
141
|
-
statusCameraLed: boolean;
|
|
142
|
-
statusCameraOutput: string | null;
|
|
143
|
-
ipAddress: string;
|
|
144
|
-
standard: "DVB" | "ATSC";
|
|
145
|
-
nullPacketsPaddingEnabled: boolean;
|
|
146
|
-
nullPacketsPaddingKbps: number;
|
|
147
|
-
videoPid: number;
|
|
148
|
-
audioPid: number;
|
|
149
|
-
mpegtsStreamId: number;
|
|
150
|
-
pmtPid: number;
|
|
151
|
-
pcrPid: number;
|
|
152
|
-
pcrPeriodMs: number;
|
|
153
|
-
providerName: string;
|
|
154
|
-
serviceName: string;
|
|
171
|
+
platform: "windy";
|
|
155
172
|
} | {
|
|
156
|
-
|
|
173
|
+
status: {
|
|
174
|
+
port: number | null;
|
|
175
|
+
led: boolean;
|
|
176
|
+
};
|
|
157
177
|
audio: {
|
|
158
|
-
source: "none";
|
|
159
|
-
} | {
|
|
160
178
|
source: "microphone";
|
|
161
179
|
audioChannelNbr: 1 | 2;
|
|
180
|
+
forceStereo: 0 | 1;
|
|
162
181
|
} | {
|
|
163
182
|
source: "file";
|
|
183
|
+
forceStereo: 0 | 1;
|
|
164
184
|
fileName: string;
|
|
165
185
|
filePath: string;
|
|
166
186
|
} | {
|
|
167
187
|
source: "url";
|
|
188
|
+
forceStereo: 0 | 1;
|
|
168
189
|
fileName: string;
|
|
169
190
|
fileUrl: string;
|
|
170
191
|
avSyncMsec: number;
|
|
171
|
-
};
|
|
192
|
+
} | null;
|
|
172
193
|
video: {
|
|
173
|
-
|
|
194
|
+
output: {
|
|
195
|
+
type: "video" | "images";
|
|
196
|
+
url: string;
|
|
197
|
+
callApi: false;
|
|
198
|
+
} | {
|
|
199
|
+
type: "video";
|
|
200
|
+
callApi: true;
|
|
201
|
+
prepareAheadS: number;
|
|
202
|
+
};
|
|
203
|
+
outputParameters: string;
|
|
204
|
+
input: {
|
|
205
|
+
type: "RTSP_URL";
|
|
206
|
+
url: string;
|
|
207
|
+
} | {
|
|
208
|
+
type: "CSw" | "CRS";
|
|
209
|
+
};
|
|
210
|
+
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
174
211
|
internalVapixParameters: string;
|
|
175
212
|
userVapixParameters: string;
|
|
176
|
-
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
177
|
-
sourceUrl?: string | undefined;
|
|
178
213
|
streamDelay?: {
|
|
179
214
|
value: number;
|
|
180
215
|
unit: "seconds" | "minutes" | "hours";
|
|
181
216
|
} | undefined;
|
|
182
217
|
};
|
|
183
218
|
enabled: boolean;
|
|
184
|
-
|
|
219
|
+
streamId: string;
|
|
185
220
|
active: boolean;
|
|
186
221
|
title: string;
|
|
187
222
|
trigger: {
|
|
188
223
|
type: "manual";
|
|
189
|
-
ioPort:
|
|
224
|
+
ioPort: number | null;
|
|
190
225
|
} | {
|
|
191
226
|
type: "onetime";
|
|
192
|
-
ioPort: string | null;
|
|
193
227
|
startTime: number;
|
|
194
228
|
stopTime: number;
|
|
195
229
|
} | {
|
|
@@ -206,50 +240,73 @@ export declare class CamStreamerAPI<Client extends IClient<TResponse, any>> {
|
|
|
206
240
|
isActive: boolean;
|
|
207
241
|
}[];
|
|
208
242
|
};
|
|
209
|
-
|
|
210
|
-
|
|
211
|
-
|
|
212
|
-
|
|
213
|
-
|
|
214
|
-
|
|
243
|
+
streamPrivacy: "public" | "unlisted" | "private";
|
|
244
|
+
platform: "youtube";
|
|
245
|
+
countdown: boolean;
|
|
246
|
+
tags: string[];
|
|
247
|
+
latency: "normal" | "low" | "ultra_low";
|
|
248
|
+
afterEndStatus: "public" | "unlisted" | "private" | "no_change";
|
|
249
|
+
dvr: boolean;
|
|
250
|
+
hasWatchdogs: boolean;
|
|
251
|
+
enableManualControl: boolean;
|
|
252
|
+
playlist?: string | undefined;
|
|
253
|
+
description?: string | undefined;
|
|
254
|
+
notificationEmail?: string[] | undefined;
|
|
215
255
|
} | {
|
|
216
|
-
|
|
256
|
+
status: {
|
|
257
|
+
port: number | null;
|
|
258
|
+
led: boolean;
|
|
259
|
+
};
|
|
217
260
|
audio: {
|
|
218
|
-
source: "none";
|
|
219
|
-
} | {
|
|
220
261
|
source: "microphone";
|
|
221
262
|
audioChannelNbr: 1 | 2;
|
|
263
|
+
forceStereo: 0 | 1;
|
|
222
264
|
} | {
|
|
223
265
|
source: "file";
|
|
266
|
+
forceStereo: 0 | 1;
|
|
224
267
|
fileName: string;
|
|
225
268
|
filePath: string;
|
|
226
269
|
} | {
|
|
227
270
|
source: "url";
|
|
271
|
+
forceStereo: 0 | 1;
|
|
228
272
|
fileName: string;
|
|
229
273
|
fileUrl: string;
|
|
230
274
|
avSyncMsec: number;
|
|
231
|
-
};
|
|
275
|
+
} | null;
|
|
232
276
|
video: {
|
|
233
|
-
|
|
277
|
+
output: {
|
|
278
|
+
type: "video" | "images";
|
|
279
|
+
url: string;
|
|
280
|
+
callApi: false;
|
|
281
|
+
} | {
|
|
282
|
+
type: "video";
|
|
283
|
+
callApi: true;
|
|
284
|
+
prepareAheadS: number;
|
|
285
|
+
};
|
|
286
|
+
outputParameters: string;
|
|
287
|
+
input: {
|
|
288
|
+
type: "RTSP_URL";
|
|
289
|
+
url: string;
|
|
290
|
+
} | {
|
|
291
|
+
type: "CSw" | "CRS";
|
|
292
|
+
};
|
|
293
|
+
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
234
294
|
internalVapixParameters: string;
|
|
235
295
|
userVapixParameters: string;
|
|
236
|
-
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
237
|
-
sourceUrl?: string | undefined;
|
|
238
296
|
streamDelay?: {
|
|
239
297
|
value: number;
|
|
240
298
|
unit: "seconds" | "minutes" | "hours";
|
|
241
299
|
} | undefined;
|
|
242
300
|
};
|
|
243
301
|
enabled: boolean;
|
|
244
|
-
|
|
302
|
+
streamId: string;
|
|
245
303
|
active: boolean;
|
|
246
304
|
title: string;
|
|
247
305
|
trigger: {
|
|
248
306
|
type: "manual";
|
|
249
|
-
ioPort:
|
|
307
|
+
ioPort: number | null;
|
|
250
308
|
} | {
|
|
251
309
|
type: "onetime";
|
|
252
|
-
ioPort: string | null;
|
|
253
310
|
startTime: number;
|
|
254
311
|
stopTime: number;
|
|
255
312
|
} | {
|
|
@@ -266,44 +323,62 @@ export declare class CamStreamerAPI<Client extends IClient<TResponse, any>> {
|
|
|
266
323
|
isActive: boolean;
|
|
267
324
|
}[];
|
|
268
325
|
};
|
|
326
|
+
platform: "church";
|
|
269
327
|
} | {
|
|
270
|
-
|
|
328
|
+
status: {
|
|
329
|
+
port: number | null;
|
|
330
|
+
led: boolean;
|
|
331
|
+
};
|
|
271
332
|
audio: {
|
|
272
|
-
source: "none";
|
|
273
|
-
} | {
|
|
274
333
|
source: "microphone";
|
|
275
334
|
audioChannelNbr: 1 | 2;
|
|
335
|
+
forceStereo: 0 | 1;
|
|
276
336
|
} | {
|
|
277
337
|
source: "file";
|
|
338
|
+
forceStereo: 0 | 1;
|
|
278
339
|
fileName: string;
|
|
279
340
|
filePath: string;
|
|
280
341
|
} | {
|
|
281
342
|
source: "url";
|
|
343
|
+
forceStereo: 0 | 1;
|
|
282
344
|
fileName: string;
|
|
283
345
|
fileUrl: string;
|
|
284
346
|
avSyncMsec: number;
|
|
285
|
-
};
|
|
347
|
+
} | null;
|
|
286
348
|
video: {
|
|
287
|
-
|
|
349
|
+
output: {
|
|
350
|
+
type: "video" | "images";
|
|
351
|
+
url: string;
|
|
352
|
+
callApi: false;
|
|
353
|
+
} | {
|
|
354
|
+
type: "video";
|
|
355
|
+
callApi: true;
|
|
356
|
+
prepareAheadS: number;
|
|
357
|
+
};
|
|
358
|
+
outputParameters: string;
|
|
359
|
+
input: {
|
|
360
|
+
type: "RTSP_URL";
|
|
361
|
+
url: string;
|
|
362
|
+
} | {
|
|
363
|
+
type: "CSw" | "CRS";
|
|
364
|
+
};
|
|
365
|
+
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
288
366
|
internalVapixParameters: string;
|
|
289
367
|
userVapixParameters: string;
|
|
290
|
-
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
291
|
-
sourceUrl?: string | undefined;
|
|
292
368
|
streamDelay?: {
|
|
293
369
|
value: number;
|
|
294
370
|
unit: "seconds" | "minutes" | "hours";
|
|
295
371
|
} | undefined;
|
|
296
372
|
};
|
|
297
373
|
enabled: boolean;
|
|
298
|
-
|
|
374
|
+
streamId: string;
|
|
299
375
|
active: boolean;
|
|
300
376
|
title: string;
|
|
301
377
|
trigger: {
|
|
302
378
|
type: "manual";
|
|
303
|
-
ioPort:
|
|
379
|
+
ioPort: number | null;
|
|
304
380
|
} | {
|
|
305
381
|
type: "onetime";
|
|
306
|
-
ioPort: string | null;
|
|
307
382
|
startTime: number;
|
|
308
383
|
stopTime: number;
|
|
309
384
|
} | {
|
|
@@ -320,44 +395,62 @@ export declare class CamStreamerAPI<Client extends IClient<TResponse, any>> {
|
|
|
320
395
|
isActive: boolean;
|
|
321
396
|
}[];
|
|
322
397
|
};
|
|
398
|
+
platform: "da_cast";
|
|
323
399
|
} | {
|
|
324
|
-
|
|
400
|
+
status: {
|
|
401
|
+
port: number | null;
|
|
402
|
+
led: boolean;
|
|
403
|
+
};
|
|
325
404
|
audio: {
|
|
326
|
-
source: "none";
|
|
327
|
-
} | {
|
|
328
405
|
source: "microphone";
|
|
329
406
|
audioChannelNbr: 1 | 2;
|
|
407
|
+
forceStereo: 0 | 1;
|
|
330
408
|
} | {
|
|
331
409
|
source: "file";
|
|
410
|
+
forceStereo: 0 | 1;
|
|
332
411
|
fileName: string;
|
|
333
412
|
filePath: string;
|
|
334
413
|
} | {
|
|
335
414
|
source: "url";
|
|
415
|
+
forceStereo: 0 | 1;
|
|
336
416
|
fileName: string;
|
|
337
417
|
fileUrl: string;
|
|
338
418
|
avSyncMsec: number;
|
|
339
|
-
};
|
|
419
|
+
} | null;
|
|
340
420
|
video: {
|
|
341
|
-
|
|
421
|
+
output: {
|
|
422
|
+
type: "video" | "images";
|
|
423
|
+
url: string;
|
|
424
|
+
callApi: false;
|
|
425
|
+
} | {
|
|
426
|
+
type: "video";
|
|
427
|
+
callApi: true;
|
|
428
|
+
prepareAheadS: number;
|
|
429
|
+
};
|
|
430
|
+
outputParameters: string;
|
|
431
|
+
input: {
|
|
432
|
+
type: "RTSP_URL";
|
|
433
|
+
url: string;
|
|
434
|
+
} | {
|
|
435
|
+
type: "CSw" | "CRS";
|
|
436
|
+
};
|
|
437
|
+
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
342
438
|
internalVapixParameters: string;
|
|
343
439
|
userVapixParameters: string;
|
|
344
|
-
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
345
|
-
sourceUrl?: string | undefined;
|
|
346
440
|
streamDelay?: {
|
|
347
441
|
value: number;
|
|
348
442
|
unit: "seconds" | "minutes" | "hours";
|
|
349
443
|
} | undefined;
|
|
350
444
|
};
|
|
351
445
|
enabled: boolean;
|
|
352
|
-
|
|
446
|
+
streamId: string;
|
|
353
447
|
active: boolean;
|
|
354
448
|
title: string;
|
|
355
449
|
trigger: {
|
|
356
450
|
type: "manual";
|
|
357
|
-
ioPort:
|
|
451
|
+
ioPort: number | null;
|
|
358
452
|
} | {
|
|
359
453
|
type: "onetime";
|
|
360
|
-
ioPort: string | null;
|
|
361
454
|
startTime: number;
|
|
362
455
|
stopTime: number;
|
|
363
456
|
} | {
|
|
@@ -374,58 +467,62 @@ export declare class CamStreamerAPI<Client extends IClient<TResponse, any>> {
|
|
|
374
467
|
isActive: boolean;
|
|
375
468
|
}[];
|
|
376
469
|
};
|
|
377
|
-
|
|
378
|
-
saveToSdCard: boolean;
|
|
379
|
-
statusCameraLed: boolean;
|
|
380
|
-
statusCameraOutput: string | null;
|
|
381
|
-
countdown: boolean;
|
|
382
|
-
tags: string[];
|
|
383
|
-
latency: "normal" | "low" | "ultra_low";
|
|
384
|
-
afterEndStatus: "public" | "unlisted" | "private" | "no_change";
|
|
385
|
-
dvr: boolean;
|
|
386
|
-
hasWatchdogs: boolean;
|
|
387
|
-
enableManualControl: boolean;
|
|
388
|
-
playlist?: string | undefined;
|
|
389
|
-
description?: string | undefined;
|
|
390
|
-
notificationEmail?: string[] | undefined;
|
|
470
|
+
platform: "dailymotion";
|
|
391
471
|
} | {
|
|
392
|
-
|
|
472
|
+
status: {
|
|
473
|
+
port: number | null;
|
|
474
|
+
led: boolean;
|
|
475
|
+
};
|
|
393
476
|
audio: {
|
|
394
|
-
source: "none";
|
|
395
|
-
} | {
|
|
396
477
|
source: "microphone";
|
|
397
478
|
audioChannelNbr: 1 | 2;
|
|
479
|
+
forceStereo: 0 | 1;
|
|
398
480
|
} | {
|
|
399
481
|
source: "file";
|
|
482
|
+
forceStereo: 0 | 1;
|
|
400
483
|
fileName: string;
|
|
401
484
|
filePath: string;
|
|
402
485
|
} | {
|
|
403
486
|
source: "url";
|
|
487
|
+
forceStereo: 0 | 1;
|
|
404
488
|
fileName: string;
|
|
405
489
|
fileUrl: string;
|
|
406
490
|
avSyncMsec: number;
|
|
407
|
-
};
|
|
491
|
+
} | null;
|
|
408
492
|
video: {
|
|
409
|
-
|
|
493
|
+
output: {
|
|
494
|
+
type: "video" | "images";
|
|
495
|
+
url: string;
|
|
496
|
+
callApi: false;
|
|
497
|
+
} | {
|
|
498
|
+
type: "video";
|
|
499
|
+
callApi: true;
|
|
500
|
+
prepareAheadS: number;
|
|
501
|
+
};
|
|
502
|
+
outputParameters: string;
|
|
503
|
+
input: {
|
|
504
|
+
type: "RTSP_URL";
|
|
505
|
+
url: string;
|
|
506
|
+
} | {
|
|
507
|
+
type: "CSw" | "CRS";
|
|
508
|
+
};
|
|
509
|
+
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
410
510
|
internalVapixParameters: string;
|
|
411
511
|
userVapixParameters: string;
|
|
412
|
-
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
413
|
-
sourceUrl?: string | undefined;
|
|
414
512
|
streamDelay?: {
|
|
415
513
|
value: number;
|
|
416
514
|
unit: "seconds" | "minutes" | "hours";
|
|
417
515
|
} | undefined;
|
|
418
516
|
};
|
|
419
517
|
enabled: boolean;
|
|
420
|
-
|
|
518
|
+
streamId: string;
|
|
421
519
|
active: boolean;
|
|
422
520
|
title: string;
|
|
423
521
|
trigger: {
|
|
424
522
|
type: "manual";
|
|
425
|
-
ioPort:
|
|
523
|
+
ioPort: number | null;
|
|
426
524
|
} | {
|
|
427
525
|
type: "onetime";
|
|
428
|
-
ioPort: string | null;
|
|
429
526
|
startTime: number;
|
|
430
527
|
stopTime: number;
|
|
431
528
|
} | {
|
|
@@ -442,44 +539,64 @@ export declare class CamStreamerAPI<Client extends IClient<TResponse, any>> {
|
|
|
442
539
|
isActive: boolean;
|
|
443
540
|
}[];
|
|
444
541
|
};
|
|
542
|
+
platform: "game_changer";
|
|
543
|
+
streamKey: string;
|
|
544
|
+
streamIdentifier?: string | undefined;
|
|
445
545
|
} | {
|
|
446
|
-
|
|
546
|
+
status: {
|
|
547
|
+
port: number | null;
|
|
548
|
+
led: boolean;
|
|
549
|
+
};
|
|
447
550
|
audio: {
|
|
448
|
-
source: "none";
|
|
449
|
-
} | {
|
|
450
551
|
source: "microphone";
|
|
451
552
|
audioChannelNbr: 1 | 2;
|
|
553
|
+
forceStereo: 0 | 1;
|
|
452
554
|
} | {
|
|
453
555
|
source: "file";
|
|
556
|
+
forceStereo: 0 | 1;
|
|
454
557
|
fileName: string;
|
|
455
558
|
filePath: string;
|
|
456
559
|
} | {
|
|
457
560
|
source: "url";
|
|
561
|
+
forceStereo: 0 | 1;
|
|
458
562
|
fileName: string;
|
|
459
563
|
fileUrl: string;
|
|
460
564
|
avSyncMsec: number;
|
|
461
|
-
};
|
|
565
|
+
} | null;
|
|
462
566
|
video: {
|
|
463
|
-
|
|
567
|
+
output: {
|
|
568
|
+
type: "video" | "images";
|
|
569
|
+
url: string;
|
|
570
|
+
callApi: false;
|
|
571
|
+
} | {
|
|
572
|
+
type: "video";
|
|
573
|
+
callApi: true;
|
|
574
|
+
prepareAheadS: number;
|
|
575
|
+
};
|
|
576
|
+
outputParameters: string;
|
|
577
|
+
input: {
|
|
578
|
+
type: "RTSP_URL";
|
|
579
|
+
url: string;
|
|
580
|
+
} | {
|
|
581
|
+
type: "CSw" | "CRS";
|
|
582
|
+
};
|
|
583
|
+
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
464
584
|
internalVapixParameters: string;
|
|
465
585
|
userVapixParameters: string;
|
|
466
|
-
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
467
|
-
sourceUrl?: string | undefined;
|
|
468
586
|
streamDelay?: {
|
|
469
587
|
value: number;
|
|
470
588
|
unit: "seconds" | "minutes" | "hours";
|
|
471
589
|
} | undefined;
|
|
472
590
|
};
|
|
473
591
|
enabled: boolean;
|
|
474
|
-
|
|
592
|
+
streamId: string;
|
|
475
593
|
active: boolean;
|
|
476
594
|
title: string;
|
|
477
595
|
trigger: {
|
|
478
596
|
type: "manual";
|
|
479
|
-
ioPort:
|
|
597
|
+
ioPort: number | null;
|
|
480
598
|
} | {
|
|
481
599
|
type: "onetime";
|
|
482
|
-
ioPort: string | null;
|
|
483
600
|
startTime: number;
|
|
484
601
|
stopTime: number;
|
|
485
602
|
} | {
|
|
@@ -496,44 +613,62 @@ export declare class CamStreamerAPI<Client extends IClient<TResponse, any>> {
|
|
|
496
613
|
isActive: boolean;
|
|
497
614
|
}[];
|
|
498
615
|
};
|
|
616
|
+
platform: "hls_pull";
|
|
499
617
|
} | {
|
|
500
|
-
|
|
618
|
+
status: {
|
|
619
|
+
port: number | null;
|
|
620
|
+
led: boolean;
|
|
621
|
+
};
|
|
501
622
|
audio: {
|
|
502
|
-
source: "none";
|
|
503
|
-
} | {
|
|
504
623
|
source: "microphone";
|
|
505
624
|
audioChannelNbr: 1 | 2;
|
|
625
|
+
forceStereo: 0 | 1;
|
|
506
626
|
} | {
|
|
507
627
|
source: "file";
|
|
628
|
+
forceStereo: 0 | 1;
|
|
508
629
|
fileName: string;
|
|
509
630
|
filePath: string;
|
|
510
631
|
} | {
|
|
511
632
|
source: "url";
|
|
633
|
+
forceStereo: 0 | 1;
|
|
512
634
|
fileName: string;
|
|
513
635
|
fileUrl: string;
|
|
514
636
|
avSyncMsec: number;
|
|
515
|
-
};
|
|
637
|
+
} | null;
|
|
516
638
|
video: {
|
|
517
|
-
|
|
639
|
+
output: {
|
|
640
|
+
type: "video" | "images";
|
|
641
|
+
url: string;
|
|
642
|
+
callApi: false;
|
|
643
|
+
} | {
|
|
644
|
+
type: "video";
|
|
645
|
+
callApi: true;
|
|
646
|
+
prepareAheadS: number;
|
|
647
|
+
};
|
|
648
|
+
outputParameters: string;
|
|
649
|
+
input: {
|
|
650
|
+
type: "RTSP_URL";
|
|
651
|
+
url: string;
|
|
652
|
+
} | {
|
|
653
|
+
type: "CSw" | "CRS";
|
|
654
|
+
};
|
|
655
|
+
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
518
656
|
internalVapixParameters: string;
|
|
519
657
|
userVapixParameters: string;
|
|
520
|
-
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
521
|
-
sourceUrl?: string | undefined;
|
|
522
658
|
streamDelay?: {
|
|
523
659
|
value: number;
|
|
524
660
|
unit: "seconds" | "minutes" | "hours";
|
|
525
661
|
} | undefined;
|
|
526
662
|
};
|
|
527
663
|
enabled: boolean;
|
|
528
|
-
|
|
664
|
+
streamId: string;
|
|
529
665
|
active: boolean;
|
|
530
666
|
title: string;
|
|
531
667
|
trigger: {
|
|
532
668
|
type: "manual";
|
|
533
|
-
ioPort:
|
|
669
|
+
ioPort: number | null;
|
|
534
670
|
} | {
|
|
535
671
|
type: "onetime";
|
|
536
|
-
ioPort: string | null;
|
|
537
672
|
startTime: number;
|
|
538
673
|
stopTime: number;
|
|
539
674
|
} | {
|
|
@@ -550,44 +685,62 @@ export declare class CamStreamerAPI<Client extends IClient<TResponse, any>> {
|
|
|
550
685
|
isActive: boolean;
|
|
551
686
|
}[];
|
|
552
687
|
};
|
|
688
|
+
platform: "hls_push";
|
|
553
689
|
} | {
|
|
554
|
-
|
|
690
|
+
status: {
|
|
691
|
+
port: number | null;
|
|
692
|
+
led: boolean;
|
|
693
|
+
};
|
|
555
694
|
audio: {
|
|
556
|
-
source: "none";
|
|
557
|
-
} | {
|
|
558
695
|
source: "microphone";
|
|
559
696
|
audioChannelNbr: 1 | 2;
|
|
697
|
+
forceStereo: 0 | 1;
|
|
560
698
|
} | {
|
|
561
699
|
source: "file";
|
|
700
|
+
forceStereo: 0 | 1;
|
|
562
701
|
fileName: string;
|
|
563
702
|
filePath: string;
|
|
564
703
|
} | {
|
|
565
704
|
source: "url";
|
|
705
|
+
forceStereo: 0 | 1;
|
|
566
706
|
fileName: string;
|
|
567
707
|
fileUrl: string;
|
|
568
708
|
avSyncMsec: number;
|
|
569
|
-
};
|
|
709
|
+
} | null;
|
|
570
710
|
video: {
|
|
571
|
-
|
|
711
|
+
output: {
|
|
712
|
+
type: "video" | "images";
|
|
713
|
+
url: string;
|
|
714
|
+
callApi: false;
|
|
715
|
+
} | {
|
|
716
|
+
type: "video";
|
|
717
|
+
callApi: true;
|
|
718
|
+
prepareAheadS: number;
|
|
719
|
+
};
|
|
720
|
+
outputParameters: string;
|
|
721
|
+
input: {
|
|
722
|
+
type: "RTSP_URL";
|
|
723
|
+
url: string;
|
|
724
|
+
} | {
|
|
725
|
+
type: "CSw" | "CRS";
|
|
726
|
+
};
|
|
727
|
+
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
572
728
|
internalVapixParameters: string;
|
|
573
729
|
userVapixParameters: string;
|
|
574
|
-
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
575
|
-
sourceUrl?: string | undefined;
|
|
576
730
|
streamDelay?: {
|
|
577
731
|
value: number;
|
|
578
732
|
unit: "seconds" | "minutes" | "hours";
|
|
579
733
|
} | undefined;
|
|
580
734
|
};
|
|
581
735
|
enabled: boolean;
|
|
582
|
-
|
|
736
|
+
streamId: string;
|
|
583
737
|
active: boolean;
|
|
584
738
|
title: string;
|
|
585
739
|
trigger: {
|
|
586
740
|
type: "manual";
|
|
587
|
-
ioPort:
|
|
741
|
+
ioPort: number | null;
|
|
588
742
|
} | {
|
|
589
743
|
type: "onetime";
|
|
590
|
-
ioPort: string | null;
|
|
591
744
|
startTime: number;
|
|
592
745
|
stopTime: number;
|
|
593
746
|
} | {
|
|
@@ -604,44 +757,62 @@ export declare class CamStreamerAPI<Client extends IClient<TResponse, any>> {
|
|
|
604
757
|
isActive: boolean;
|
|
605
758
|
}[];
|
|
606
759
|
};
|
|
760
|
+
platform: "ibm";
|
|
607
761
|
} | {
|
|
608
|
-
|
|
762
|
+
status: {
|
|
763
|
+
port: number | null;
|
|
764
|
+
led: boolean;
|
|
765
|
+
};
|
|
609
766
|
audio: {
|
|
610
|
-
source: "none";
|
|
611
|
-
} | {
|
|
612
767
|
source: "microphone";
|
|
613
768
|
audioChannelNbr: 1 | 2;
|
|
769
|
+
forceStereo: 0 | 1;
|
|
614
770
|
} | {
|
|
615
771
|
source: "file";
|
|
772
|
+
forceStereo: 0 | 1;
|
|
616
773
|
fileName: string;
|
|
617
774
|
filePath: string;
|
|
618
775
|
} | {
|
|
619
776
|
source: "url";
|
|
777
|
+
forceStereo: 0 | 1;
|
|
620
778
|
fileName: string;
|
|
621
779
|
fileUrl: string;
|
|
622
780
|
avSyncMsec: number;
|
|
623
|
-
};
|
|
781
|
+
} | null;
|
|
624
782
|
video: {
|
|
625
|
-
|
|
783
|
+
output: {
|
|
784
|
+
type: "video" | "images";
|
|
785
|
+
url: string;
|
|
786
|
+
callApi: false;
|
|
787
|
+
} | {
|
|
788
|
+
type: "video";
|
|
789
|
+
callApi: true;
|
|
790
|
+
prepareAheadS: number;
|
|
791
|
+
};
|
|
792
|
+
outputParameters: string;
|
|
793
|
+
input: {
|
|
794
|
+
type: "RTSP_URL";
|
|
795
|
+
url: string;
|
|
796
|
+
} | {
|
|
797
|
+
type: "CSw" | "CRS";
|
|
798
|
+
};
|
|
799
|
+
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
626
800
|
internalVapixParameters: string;
|
|
627
801
|
userVapixParameters: string;
|
|
628
|
-
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
629
|
-
sourceUrl?: string | undefined;
|
|
630
802
|
streamDelay?: {
|
|
631
803
|
value: number;
|
|
632
804
|
unit: "seconds" | "minutes" | "hours";
|
|
633
805
|
} | undefined;
|
|
634
806
|
};
|
|
635
807
|
enabled: boolean;
|
|
636
|
-
|
|
808
|
+
streamId: string;
|
|
637
809
|
active: boolean;
|
|
638
810
|
title: string;
|
|
639
811
|
trigger: {
|
|
640
812
|
type: "manual";
|
|
641
|
-
ioPort:
|
|
813
|
+
ioPort: number | null;
|
|
642
814
|
} | {
|
|
643
815
|
type: "onetime";
|
|
644
|
-
ioPort: string | null;
|
|
645
816
|
startTime: number;
|
|
646
817
|
stopTime: number;
|
|
647
818
|
} | {
|
|
@@ -658,44 +829,62 @@ export declare class CamStreamerAPI<Client extends IClient<TResponse, any>> {
|
|
|
658
829
|
isActive: boolean;
|
|
659
830
|
}[];
|
|
660
831
|
};
|
|
832
|
+
platform: "mpeg_dvb";
|
|
661
833
|
} | {
|
|
662
|
-
|
|
834
|
+
status: {
|
|
835
|
+
port: number | null;
|
|
836
|
+
led: boolean;
|
|
837
|
+
};
|
|
663
838
|
audio: {
|
|
664
|
-
source: "none";
|
|
665
|
-
} | {
|
|
666
839
|
source: "microphone";
|
|
667
840
|
audioChannelNbr: 1 | 2;
|
|
841
|
+
forceStereo: 0 | 1;
|
|
668
842
|
} | {
|
|
669
843
|
source: "file";
|
|
844
|
+
forceStereo: 0 | 1;
|
|
670
845
|
fileName: string;
|
|
671
846
|
filePath: string;
|
|
672
847
|
} | {
|
|
673
848
|
source: "url";
|
|
849
|
+
forceStereo: 0 | 1;
|
|
674
850
|
fileName: string;
|
|
675
851
|
fileUrl: string;
|
|
676
852
|
avSyncMsec: number;
|
|
677
|
-
};
|
|
853
|
+
} | null;
|
|
678
854
|
video: {
|
|
679
|
-
|
|
855
|
+
output: {
|
|
856
|
+
type: "video" | "images";
|
|
857
|
+
url: string;
|
|
858
|
+
callApi: false;
|
|
859
|
+
} | {
|
|
860
|
+
type: "video";
|
|
861
|
+
callApi: true;
|
|
862
|
+
prepareAheadS: number;
|
|
863
|
+
};
|
|
864
|
+
outputParameters: string;
|
|
865
|
+
input: {
|
|
866
|
+
type: "RTSP_URL";
|
|
867
|
+
url: string;
|
|
868
|
+
} | {
|
|
869
|
+
type: "CSw" | "CRS";
|
|
870
|
+
};
|
|
871
|
+
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
680
872
|
internalVapixParameters: string;
|
|
681
873
|
userVapixParameters: string;
|
|
682
|
-
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
683
|
-
sourceUrl?: string | undefined;
|
|
684
874
|
streamDelay?: {
|
|
685
875
|
value: number;
|
|
686
876
|
unit: "seconds" | "minutes" | "hours";
|
|
687
877
|
} | undefined;
|
|
688
878
|
};
|
|
689
879
|
enabled: boolean;
|
|
690
|
-
|
|
880
|
+
streamId: string;
|
|
691
881
|
active: boolean;
|
|
692
882
|
title: string;
|
|
693
883
|
trigger: {
|
|
694
884
|
type: "manual";
|
|
695
|
-
ioPort:
|
|
885
|
+
ioPort: number | null;
|
|
696
886
|
} | {
|
|
697
887
|
type: "onetime";
|
|
698
|
-
ioPort: string | null;
|
|
699
888
|
startTime: number;
|
|
700
889
|
stopTime: number;
|
|
701
890
|
} | {
|
|
@@ -712,44 +901,62 @@ export declare class CamStreamerAPI<Client extends IClient<TResponse, any>> {
|
|
|
712
901
|
isActive: boolean;
|
|
713
902
|
}[];
|
|
714
903
|
};
|
|
904
|
+
platform: "microsoft_azure";
|
|
715
905
|
} | {
|
|
716
|
-
|
|
906
|
+
status: {
|
|
907
|
+
port: number | null;
|
|
908
|
+
led: boolean;
|
|
909
|
+
};
|
|
717
910
|
audio: {
|
|
718
|
-
source: "none";
|
|
719
|
-
} | {
|
|
720
911
|
source: "microphone";
|
|
721
912
|
audioChannelNbr: 1 | 2;
|
|
913
|
+
forceStereo: 0 | 1;
|
|
722
914
|
} | {
|
|
723
915
|
source: "file";
|
|
916
|
+
forceStereo: 0 | 1;
|
|
724
917
|
fileName: string;
|
|
725
918
|
filePath: string;
|
|
726
919
|
} | {
|
|
727
920
|
source: "url";
|
|
921
|
+
forceStereo: 0 | 1;
|
|
728
922
|
fileName: string;
|
|
729
923
|
fileUrl: string;
|
|
730
924
|
avSyncMsec: number;
|
|
731
|
-
};
|
|
925
|
+
} | null;
|
|
732
926
|
video: {
|
|
733
|
-
|
|
927
|
+
output: {
|
|
928
|
+
type: "video" | "images";
|
|
929
|
+
url: string;
|
|
930
|
+
callApi: false;
|
|
931
|
+
} | {
|
|
932
|
+
type: "video";
|
|
933
|
+
callApi: true;
|
|
934
|
+
prepareAheadS: number;
|
|
935
|
+
};
|
|
936
|
+
outputParameters: string;
|
|
937
|
+
input: {
|
|
938
|
+
type: "RTSP_URL";
|
|
939
|
+
url: string;
|
|
940
|
+
} | {
|
|
941
|
+
type: "CSw" | "CRS";
|
|
942
|
+
};
|
|
943
|
+
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
734
944
|
internalVapixParameters: string;
|
|
735
945
|
userVapixParameters: string;
|
|
736
|
-
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
737
|
-
sourceUrl?: string | undefined;
|
|
738
946
|
streamDelay?: {
|
|
739
947
|
value: number;
|
|
740
948
|
unit: "seconds" | "minutes" | "hours";
|
|
741
949
|
} | undefined;
|
|
742
950
|
};
|
|
743
951
|
enabled: boolean;
|
|
744
|
-
|
|
952
|
+
streamId: string;
|
|
745
953
|
active: boolean;
|
|
746
954
|
title: string;
|
|
747
955
|
trigger: {
|
|
748
956
|
type: "manual";
|
|
749
|
-
ioPort:
|
|
957
|
+
ioPort: number | null;
|
|
750
958
|
} | {
|
|
751
959
|
type: "onetime";
|
|
752
|
-
ioPort: string | null;
|
|
753
960
|
startTime: number;
|
|
754
961
|
stopTime: number;
|
|
755
962
|
} | {
|
|
@@ -766,44 +973,62 @@ export declare class CamStreamerAPI<Client extends IClient<TResponse, any>> {
|
|
|
766
973
|
isActive: boolean;
|
|
767
974
|
}[];
|
|
768
975
|
};
|
|
976
|
+
platform: "microsoft_stream";
|
|
769
977
|
} | {
|
|
770
|
-
|
|
978
|
+
status: {
|
|
979
|
+
port: number | null;
|
|
980
|
+
led: boolean;
|
|
981
|
+
};
|
|
771
982
|
audio: {
|
|
772
|
-
source: "none";
|
|
773
|
-
} | {
|
|
774
983
|
source: "microphone";
|
|
775
984
|
audioChannelNbr: 1 | 2;
|
|
985
|
+
forceStereo: 0 | 1;
|
|
776
986
|
} | {
|
|
777
987
|
source: "file";
|
|
988
|
+
forceStereo: 0 | 1;
|
|
778
989
|
fileName: string;
|
|
779
990
|
filePath: string;
|
|
780
991
|
} | {
|
|
781
992
|
source: "url";
|
|
993
|
+
forceStereo: 0 | 1;
|
|
782
994
|
fileName: string;
|
|
783
995
|
fileUrl: string;
|
|
784
996
|
avSyncMsec: number;
|
|
785
|
-
};
|
|
997
|
+
} | null;
|
|
786
998
|
video: {
|
|
787
|
-
|
|
999
|
+
output: {
|
|
1000
|
+
type: "video" | "images";
|
|
1001
|
+
url: string;
|
|
1002
|
+
callApi: false;
|
|
1003
|
+
} | {
|
|
1004
|
+
type: "video";
|
|
1005
|
+
callApi: true;
|
|
1006
|
+
prepareAheadS: number;
|
|
1007
|
+
};
|
|
1008
|
+
outputParameters: string;
|
|
1009
|
+
input: {
|
|
1010
|
+
type: "RTSP_URL";
|
|
1011
|
+
url: string;
|
|
1012
|
+
} | {
|
|
1013
|
+
type: "CSw" | "CRS";
|
|
1014
|
+
};
|
|
1015
|
+
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
788
1016
|
internalVapixParameters: string;
|
|
789
1017
|
userVapixParameters: string;
|
|
790
|
-
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
791
|
-
sourceUrl?: string | undefined;
|
|
792
1018
|
streamDelay?: {
|
|
793
1019
|
value: number;
|
|
794
1020
|
unit: "seconds" | "minutes" | "hours";
|
|
795
1021
|
} | undefined;
|
|
796
1022
|
};
|
|
797
1023
|
enabled: boolean;
|
|
798
|
-
|
|
1024
|
+
streamId: string;
|
|
799
1025
|
active: boolean;
|
|
800
1026
|
title: string;
|
|
801
1027
|
trigger: {
|
|
802
1028
|
type: "manual";
|
|
803
|
-
ioPort:
|
|
1029
|
+
ioPort: number | null;
|
|
804
1030
|
} | {
|
|
805
1031
|
type: "onetime";
|
|
806
|
-
ioPort: string | null;
|
|
807
1032
|
startTime: number;
|
|
808
1033
|
stopTime: number;
|
|
809
1034
|
} | {
|
|
@@ -820,44 +1045,64 @@ export declare class CamStreamerAPI<Client extends IClient<TResponse, any>> {
|
|
|
820
1045
|
isActive: boolean;
|
|
821
1046
|
}[];
|
|
822
1047
|
};
|
|
1048
|
+
platform: "rtmp";
|
|
1049
|
+
streamKey: string;
|
|
1050
|
+
streamIdentifier?: string | undefined;
|
|
823
1051
|
} | {
|
|
824
|
-
|
|
1052
|
+
status: {
|
|
1053
|
+
port: number | null;
|
|
1054
|
+
led: boolean;
|
|
1055
|
+
};
|
|
825
1056
|
audio: {
|
|
826
|
-
source: "none";
|
|
827
|
-
} | {
|
|
828
1057
|
source: "microphone";
|
|
829
1058
|
audioChannelNbr: 1 | 2;
|
|
1059
|
+
forceStereo: 0 | 1;
|
|
830
1060
|
} | {
|
|
831
1061
|
source: "file";
|
|
1062
|
+
forceStereo: 0 | 1;
|
|
832
1063
|
fileName: string;
|
|
833
1064
|
filePath: string;
|
|
834
1065
|
} | {
|
|
835
1066
|
source: "url";
|
|
1067
|
+
forceStereo: 0 | 1;
|
|
836
1068
|
fileName: string;
|
|
837
1069
|
fileUrl: string;
|
|
838
1070
|
avSyncMsec: number;
|
|
839
|
-
};
|
|
1071
|
+
} | null;
|
|
840
1072
|
video: {
|
|
841
|
-
|
|
1073
|
+
output: {
|
|
1074
|
+
type: "video" | "images";
|
|
1075
|
+
url: string;
|
|
1076
|
+
callApi: false;
|
|
1077
|
+
} | {
|
|
1078
|
+
type: "video";
|
|
1079
|
+
callApi: true;
|
|
1080
|
+
prepareAheadS: number;
|
|
1081
|
+
};
|
|
1082
|
+
outputParameters: string;
|
|
1083
|
+
input: {
|
|
1084
|
+
type: "RTSP_URL";
|
|
1085
|
+
url: string;
|
|
1086
|
+
} | {
|
|
1087
|
+
type: "CSw" | "CRS";
|
|
1088
|
+
};
|
|
1089
|
+
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
842
1090
|
internalVapixParameters: string;
|
|
843
1091
|
userVapixParameters: string;
|
|
844
|
-
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
845
|
-
sourceUrl?: string | undefined;
|
|
846
1092
|
streamDelay?: {
|
|
847
1093
|
value: number;
|
|
848
1094
|
unit: "seconds" | "minutes" | "hours";
|
|
849
1095
|
} | undefined;
|
|
850
1096
|
};
|
|
851
1097
|
enabled: boolean;
|
|
852
|
-
|
|
1098
|
+
streamId: string;
|
|
853
1099
|
active: boolean;
|
|
854
1100
|
title: string;
|
|
855
1101
|
trigger: {
|
|
856
1102
|
type: "manual";
|
|
857
|
-
ioPort:
|
|
1103
|
+
ioPort: number | null;
|
|
858
1104
|
} | {
|
|
859
1105
|
type: "onetime";
|
|
860
|
-
ioPort: string | null;
|
|
861
1106
|
startTime: number;
|
|
862
1107
|
stopTime: number;
|
|
863
1108
|
} | {
|
|
@@ -874,44 +1119,62 @@ export declare class CamStreamerAPI<Client extends IClient<TResponse, any>> {
|
|
|
874
1119
|
isActive: boolean;
|
|
875
1120
|
}[];
|
|
876
1121
|
};
|
|
1122
|
+
platform: "sd_card";
|
|
877
1123
|
} | {
|
|
878
|
-
|
|
1124
|
+
status: {
|
|
1125
|
+
port: number | null;
|
|
1126
|
+
led: boolean;
|
|
1127
|
+
};
|
|
879
1128
|
audio: {
|
|
880
|
-
source: "none";
|
|
881
|
-
} | {
|
|
882
1129
|
source: "microphone";
|
|
883
1130
|
audioChannelNbr: 1 | 2;
|
|
1131
|
+
forceStereo: 0 | 1;
|
|
884
1132
|
} | {
|
|
885
1133
|
source: "file";
|
|
1134
|
+
forceStereo: 0 | 1;
|
|
886
1135
|
fileName: string;
|
|
887
1136
|
filePath: string;
|
|
888
1137
|
} | {
|
|
889
1138
|
source: "url";
|
|
1139
|
+
forceStereo: 0 | 1;
|
|
890
1140
|
fileName: string;
|
|
891
1141
|
fileUrl: string;
|
|
892
1142
|
avSyncMsec: number;
|
|
893
|
-
};
|
|
1143
|
+
} | null;
|
|
894
1144
|
video: {
|
|
895
|
-
|
|
1145
|
+
output: {
|
|
1146
|
+
type: "video" | "images";
|
|
1147
|
+
url: string;
|
|
1148
|
+
callApi: false;
|
|
1149
|
+
} | {
|
|
1150
|
+
type: "video";
|
|
1151
|
+
callApi: true;
|
|
1152
|
+
prepareAheadS: number;
|
|
1153
|
+
};
|
|
1154
|
+
outputParameters: string;
|
|
1155
|
+
input: {
|
|
1156
|
+
type: "RTSP_URL";
|
|
1157
|
+
url: string;
|
|
1158
|
+
} | {
|
|
1159
|
+
type: "CSw" | "CRS";
|
|
1160
|
+
};
|
|
1161
|
+
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
896
1162
|
internalVapixParameters: string;
|
|
897
1163
|
userVapixParameters: string;
|
|
898
|
-
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
899
|
-
sourceUrl?: string | undefined;
|
|
900
1164
|
streamDelay?: {
|
|
901
1165
|
value: number;
|
|
902
1166
|
unit: "seconds" | "minutes" | "hours";
|
|
903
1167
|
} | undefined;
|
|
904
1168
|
};
|
|
905
1169
|
enabled: boolean;
|
|
906
|
-
|
|
1170
|
+
streamId: string;
|
|
907
1171
|
active: boolean;
|
|
908
1172
|
title: string;
|
|
909
1173
|
trigger: {
|
|
910
1174
|
type: "manual";
|
|
911
|
-
ioPort:
|
|
1175
|
+
ioPort: number | null;
|
|
912
1176
|
} | {
|
|
913
1177
|
type: "onetime";
|
|
914
|
-
ioPort: string | null;
|
|
915
1178
|
startTime: number;
|
|
916
1179
|
stopTime: number;
|
|
917
1180
|
} | {
|
|
@@ -928,44 +1191,62 @@ export declare class CamStreamerAPI<Client extends IClient<TResponse, any>> {
|
|
|
928
1191
|
isActive: boolean;
|
|
929
1192
|
}[];
|
|
930
1193
|
};
|
|
1194
|
+
platform: "srt";
|
|
931
1195
|
} | {
|
|
932
|
-
|
|
1196
|
+
status: {
|
|
1197
|
+
port: number | null;
|
|
1198
|
+
led: boolean;
|
|
1199
|
+
};
|
|
933
1200
|
audio: {
|
|
934
|
-
source: "none";
|
|
935
|
-
} | {
|
|
936
1201
|
source: "microphone";
|
|
937
1202
|
audioChannelNbr: 1 | 2;
|
|
1203
|
+
forceStereo: 0 | 1;
|
|
938
1204
|
} | {
|
|
939
1205
|
source: "file";
|
|
1206
|
+
forceStereo: 0 | 1;
|
|
940
1207
|
fileName: string;
|
|
941
1208
|
filePath: string;
|
|
942
1209
|
} | {
|
|
943
1210
|
source: "url";
|
|
1211
|
+
forceStereo: 0 | 1;
|
|
944
1212
|
fileName: string;
|
|
945
1213
|
fileUrl: string;
|
|
946
1214
|
avSyncMsec: number;
|
|
947
|
-
};
|
|
1215
|
+
} | null;
|
|
948
1216
|
video: {
|
|
949
|
-
|
|
1217
|
+
output: {
|
|
1218
|
+
type: "video" | "images";
|
|
1219
|
+
url: string;
|
|
1220
|
+
callApi: false;
|
|
1221
|
+
} | {
|
|
1222
|
+
type: "video";
|
|
1223
|
+
callApi: true;
|
|
1224
|
+
prepareAheadS: number;
|
|
1225
|
+
};
|
|
1226
|
+
outputParameters: string;
|
|
1227
|
+
input: {
|
|
1228
|
+
type: "RTSP_URL";
|
|
1229
|
+
url: string;
|
|
1230
|
+
} | {
|
|
1231
|
+
type: "CSw" | "CRS";
|
|
1232
|
+
};
|
|
1233
|
+
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
950
1234
|
internalVapixParameters: string;
|
|
951
1235
|
userVapixParameters: string;
|
|
952
|
-
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
953
|
-
sourceUrl?: string | undefined;
|
|
954
1236
|
streamDelay?: {
|
|
955
1237
|
value: number;
|
|
956
1238
|
unit: "seconds" | "minutes" | "hours";
|
|
957
1239
|
} | undefined;
|
|
958
1240
|
};
|
|
959
1241
|
enabled: boolean;
|
|
960
|
-
|
|
1242
|
+
streamId: string;
|
|
961
1243
|
active: boolean;
|
|
962
1244
|
title: string;
|
|
963
1245
|
trigger: {
|
|
964
1246
|
type: "manual";
|
|
965
|
-
ioPort:
|
|
1247
|
+
ioPort: number | null;
|
|
966
1248
|
} | {
|
|
967
1249
|
type: "onetime";
|
|
968
|
-
ioPort: string | null;
|
|
969
1250
|
startTime: number;
|
|
970
1251
|
stopTime: number;
|
|
971
1252
|
} | {
|
|
@@ -982,44 +1263,62 @@ export declare class CamStreamerAPI<Client extends IClient<TResponse, any>> {
|
|
|
982
1263
|
isActive: boolean;
|
|
983
1264
|
}[];
|
|
984
1265
|
};
|
|
1266
|
+
platform: "twitch";
|
|
985
1267
|
} | {
|
|
986
|
-
|
|
1268
|
+
status: {
|
|
1269
|
+
port: number | null;
|
|
1270
|
+
led: boolean;
|
|
1271
|
+
};
|
|
987
1272
|
audio: {
|
|
988
|
-
source: "none";
|
|
989
|
-
} | {
|
|
990
1273
|
source: "microphone";
|
|
991
1274
|
audioChannelNbr: 1 | 2;
|
|
1275
|
+
forceStereo: 0 | 1;
|
|
992
1276
|
} | {
|
|
993
1277
|
source: "file";
|
|
1278
|
+
forceStereo: 0 | 1;
|
|
994
1279
|
fileName: string;
|
|
995
1280
|
filePath: string;
|
|
996
1281
|
} | {
|
|
997
1282
|
source: "url";
|
|
1283
|
+
forceStereo: 0 | 1;
|
|
998
1284
|
fileName: string;
|
|
999
1285
|
fileUrl: string;
|
|
1000
1286
|
avSyncMsec: number;
|
|
1001
|
-
};
|
|
1287
|
+
} | null;
|
|
1002
1288
|
video: {
|
|
1003
|
-
|
|
1289
|
+
output: {
|
|
1290
|
+
type: "video" | "images";
|
|
1291
|
+
url: string;
|
|
1292
|
+
callApi: false;
|
|
1293
|
+
} | {
|
|
1294
|
+
type: "video";
|
|
1295
|
+
callApi: true;
|
|
1296
|
+
prepareAheadS: number;
|
|
1297
|
+
};
|
|
1298
|
+
outputParameters: string;
|
|
1299
|
+
input: {
|
|
1300
|
+
type: "RTSP_URL";
|
|
1301
|
+
url: string;
|
|
1302
|
+
} | {
|
|
1303
|
+
type: "CSw" | "CRS";
|
|
1304
|
+
};
|
|
1305
|
+
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
1004
1306
|
internalVapixParameters: string;
|
|
1005
1307
|
userVapixParameters: string;
|
|
1006
|
-
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
1007
|
-
sourceUrl?: string | undefined;
|
|
1008
1308
|
streamDelay?: {
|
|
1009
1309
|
value: number;
|
|
1010
1310
|
unit: "seconds" | "minutes" | "hours";
|
|
1011
1311
|
} | undefined;
|
|
1012
1312
|
};
|
|
1013
1313
|
enabled: boolean;
|
|
1014
|
-
|
|
1314
|
+
streamId: string;
|
|
1015
1315
|
active: boolean;
|
|
1016
1316
|
title: string;
|
|
1017
1317
|
trigger: {
|
|
1018
1318
|
type: "manual";
|
|
1019
|
-
ioPort:
|
|
1319
|
+
ioPort: number | null;
|
|
1020
1320
|
} | {
|
|
1021
1321
|
type: "onetime";
|
|
1022
|
-
ioPort: string | null;
|
|
1023
1322
|
startTime: number;
|
|
1024
1323
|
stopTime: number;
|
|
1025
1324
|
} | {
|
|
@@ -1036,44 +1335,62 @@ export declare class CamStreamerAPI<Client extends IClient<TResponse, any>> {
|
|
|
1036
1335
|
isActive: boolean;
|
|
1037
1336
|
}[];
|
|
1038
1337
|
};
|
|
1338
|
+
platform: "vimeo";
|
|
1039
1339
|
} | {
|
|
1040
|
-
|
|
1340
|
+
status: {
|
|
1341
|
+
port: number | null;
|
|
1342
|
+
led: boolean;
|
|
1343
|
+
};
|
|
1041
1344
|
audio: {
|
|
1042
|
-
source: "none";
|
|
1043
|
-
} | {
|
|
1044
1345
|
source: "microphone";
|
|
1045
1346
|
audioChannelNbr: 1 | 2;
|
|
1347
|
+
forceStereo: 0 | 1;
|
|
1046
1348
|
} | {
|
|
1047
1349
|
source: "file";
|
|
1350
|
+
forceStereo: 0 | 1;
|
|
1048
1351
|
fileName: string;
|
|
1049
1352
|
filePath: string;
|
|
1050
1353
|
} | {
|
|
1051
1354
|
source: "url";
|
|
1355
|
+
forceStereo: 0 | 1;
|
|
1052
1356
|
fileName: string;
|
|
1053
1357
|
fileUrl: string;
|
|
1054
1358
|
avSyncMsec: number;
|
|
1055
|
-
};
|
|
1359
|
+
} | null;
|
|
1056
1360
|
video: {
|
|
1057
|
-
|
|
1361
|
+
output: {
|
|
1362
|
+
type: "video" | "images";
|
|
1363
|
+
url: string;
|
|
1364
|
+
callApi: false;
|
|
1365
|
+
} | {
|
|
1366
|
+
type: "video";
|
|
1367
|
+
callApi: true;
|
|
1368
|
+
prepareAheadS: number;
|
|
1369
|
+
};
|
|
1370
|
+
outputParameters: string;
|
|
1371
|
+
input: {
|
|
1372
|
+
type: "RTSP_URL";
|
|
1373
|
+
url: string;
|
|
1374
|
+
} | {
|
|
1375
|
+
type: "CSw" | "CRS";
|
|
1376
|
+
};
|
|
1377
|
+
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
1058
1378
|
internalVapixParameters: string;
|
|
1059
1379
|
userVapixParameters: string;
|
|
1060
|
-
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
1061
|
-
sourceUrl?: string | undefined;
|
|
1062
1380
|
streamDelay?: {
|
|
1063
1381
|
value: number;
|
|
1064
1382
|
unit: "seconds" | "minutes" | "hours";
|
|
1065
1383
|
} | undefined;
|
|
1066
1384
|
};
|
|
1067
1385
|
enabled: boolean;
|
|
1068
|
-
|
|
1386
|
+
streamId: string;
|
|
1069
1387
|
active: boolean;
|
|
1070
1388
|
title: string;
|
|
1071
1389
|
trigger: {
|
|
1072
1390
|
type: "manual";
|
|
1073
|
-
ioPort:
|
|
1391
|
+
ioPort: number | null;
|
|
1074
1392
|
} | {
|
|
1075
1393
|
type: "onetime";
|
|
1076
|
-
ioPort: string | null;
|
|
1077
1394
|
startTime: number;
|
|
1078
1395
|
stopTime: number;
|
|
1079
1396
|
} | {
|
|
@@ -1090,50 +1407,62 @@ export declare class CamStreamerAPI<Client extends IClient<TResponse, any>> {
|
|
|
1090
1407
|
isActive: boolean;
|
|
1091
1408
|
}[];
|
|
1092
1409
|
};
|
|
1093
|
-
|
|
1094
|
-
statusCameraLed: boolean;
|
|
1095
|
-
statusCameraOutput: string | null;
|
|
1096
|
-
outputUrl: string;
|
|
1097
|
-
streamKey: string;
|
|
1098
|
-
streamIdentifier?: string | undefined;
|
|
1410
|
+
platform: "wowza";
|
|
1099
1411
|
} | {
|
|
1100
|
-
|
|
1412
|
+
status: {
|
|
1413
|
+
port: number | null;
|
|
1414
|
+
led: boolean;
|
|
1415
|
+
};
|
|
1101
1416
|
audio: {
|
|
1102
|
-
source: "none";
|
|
1103
|
-
} | {
|
|
1104
1417
|
source: "microphone";
|
|
1105
1418
|
audioChannelNbr: 1 | 2;
|
|
1419
|
+
forceStereo: 0 | 1;
|
|
1106
1420
|
} | {
|
|
1107
1421
|
source: "file";
|
|
1422
|
+
forceStereo: 0 | 1;
|
|
1108
1423
|
fileName: string;
|
|
1109
1424
|
filePath: string;
|
|
1110
1425
|
} | {
|
|
1111
1426
|
source: "url";
|
|
1427
|
+
forceStereo: 0 | 1;
|
|
1112
1428
|
fileName: string;
|
|
1113
1429
|
fileUrl: string;
|
|
1114
1430
|
avSyncMsec: number;
|
|
1115
|
-
};
|
|
1431
|
+
} | null;
|
|
1116
1432
|
video: {
|
|
1117
|
-
|
|
1433
|
+
output: {
|
|
1434
|
+
type: "video" | "images";
|
|
1435
|
+
url: string;
|
|
1436
|
+
callApi: false;
|
|
1437
|
+
} | {
|
|
1438
|
+
type: "video";
|
|
1439
|
+
callApi: true;
|
|
1440
|
+
prepareAheadS: number;
|
|
1441
|
+
};
|
|
1442
|
+
outputParameters: string;
|
|
1443
|
+
input: {
|
|
1444
|
+
type: "RTSP_URL";
|
|
1445
|
+
url: string;
|
|
1446
|
+
} | {
|
|
1447
|
+
type: "CSw" | "CRS";
|
|
1448
|
+
};
|
|
1449
|
+
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
1118
1450
|
internalVapixParameters: string;
|
|
1119
1451
|
userVapixParameters: string;
|
|
1120
|
-
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
1121
|
-
sourceUrl?: string | undefined;
|
|
1122
1452
|
streamDelay?: {
|
|
1123
1453
|
value: number;
|
|
1124
1454
|
unit: "seconds" | "minutes" | "hours";
|
|
1125
1455
|
} | undefined;
|
|
1126
1456
|
};
|
|
1127
1457
|
enabled: boolean;
|
|
1128
|
-
|
|
1458
|
+
streamId: string;
|
|
1129
1459
|
active: boolean;
|
|
1130
1460
|
title: string;
|
|
1131
1461
|
trigger: {
|
|
1132
1462
|
type: "manual";
|
|
1133
|
-
ioPort:
|
|
1463
|
+
ioPort: number | null;
|
|
1134
1464
|
} | {
|
|
1135
1465
|
type: "onetime";
|
|
1136
|
-
ioPort: string | null;
|
|
1137
1466
|
startTime: number;
|
|
1138
1467
|
stopTime: number;
|
|
1139
1468
|
} | {
|
|
@@ -1150,15 +1479,12 @@ export declare class CamStreamerAPI<Client extends IClient<TResponse, any>> {
|
|
|
1150
1479
|
isActive: boolean;
|
|
1151
1480
|
}[];
|
|
1152
1481
|
};
|
|
1153
|
-
|
|
1154
|
-
statusCameraLed: boolean;
|
|
1155
|
-
statusCameraOutput: string | null;
|
|
1156
|
-
outputUrl: string;
|
|
1482
|
+
platform: "youtube_rtmp";
|
|
1157
1483
|
streamKey: string;
|
|
1158
1484
|
streamIdentifier?: string | undefined;
|
|
1159
1485
|
})[]>;
|
|
1160
1486
|
setStreamList(streamList: TStreamList['streamList'], options?: THttpRequestOptions): Promise<void>;
|
|
1161
|
-
getStream(streamId:
|
|
1487
|
+
getStream(streamId: string, options?: THttpRequestOptions): Promise<{
|
|
1162
1488
|
post: {
|
|
1163
1489
|
postLocation: "timeline";
|
|
1164
1490
|
streamPrivacy: "public" | "friends" | "only_me";
|
|
@@ -1166,43 +1492,60 @@ export declare class CamStreamerAPI<Client extends IClient<TResponse, any>> {
|
|
|
1166
1492
|
postLocation: "page";
|
|
1167
1493
|
page: string;
|
|
1168
1494
|
};
|
|
1169
|
-
|
|
1495
|
+
status: {
|
|
1496
|
+
port: number | null;
|
|
1497
|
+
led: boolean;
|
|
1498
|
+
};
|
|
1170
1499
|
audio: {
|
|
1171
|
-
source: "none";
|
|
1172
|
-
} | {
|
|
1173
1500
|
source: "microphone";
|
|
1174
1501
|
audioChannelNbr: 1 | 2;
|
|
1502
|
+
forceStereo: 0 | 1;
|
|
1175
1503
|
} | {
|
|
1176
1504
|
source: "file";
|
|
1505
|
+
forceStereo: 0 | 1;
|
|
1177
1506
|
fileName: string;
|
|
1178
1507
|
filePath: string;
|
|
1179
1508
|
} | {
|
|
1180
1509
|
source: "url";
|
|
1510
|
+
forceStereo: 0 | 1;
|
|
1181
1511
|
fileName: string;
|
|
1182
1512
|
fileUrl: string;
|
|
1183
1513
|
avSyncMsec: number;
|
|
1184
|
-
};
|
|
1514
|
+
} | null;
|
|
1185
1515
|
video: {
|
|
1186
|
-
|
|
1516
|
+
output: {
|
|
1517
|
+
type: "video" | "images";
|
|
1518
|
+
url: string;
|
|
1519
|
+
callApi: false;
|
|
1520
|
+
} | {
|
|
1521
|
+
type: "video";
|
|
1522
|
+
callApi: true;
|
|
1523
|
+
prepareAheadS: number;
|
|
1524
|
+
};
|
|
1525
|
+
outputParameters: string;
|
|
1526
|
+
input: {
|
|
1527
|
+
type: "RTSP_URL";
|
|
1528
|
+
url: string;
|
|
1529
|
+
} | {
|
|
1530
|
+
type: "CSw" | "CRS";
|
|
1531
|
+
};
|
|
1532
|
+
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
1187
1533
|
internalVapixParameters: string;
|
|
1188
1534
|
userVapixParameters: string;
|
|
1189
|
-
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
1190
|
-
sourceUrl?: string | undefined;
|
|
1191
1535
|
streamDelay?: {
|
|
1192
1536
|
value: number;
|
|
1193
1537
|
unit: "seconds" | "minutes" | "hours";
|
|
1194
1538
|
} | undefined;
|
|
1195
1539
|
};
|
|
1196
1540
|
enabled: boolean;
|
|
1197
|
-
|
|
1541
|
+
streamId: string;
|
|
1198
1542
|
active: boolean;
|
|
1199
1543
|
title: string;
|
|
1200
1544
|
trigger: {
|
|
1201
1545
|
type: "manual";
|
|
1202
|
-
ioPort:
|
|
1546
|
+
ioPort: number | null;
|
|
1203
1547
|
} | {
|
|
1204
1548
|
type: "onetime";
|
|
1205
|
-
ioPort: string | null;
|
|
1206
1549
|
startTime: number;
|
|
1207
1550
|
stopTime: number;
|
|
1208
1551
|
} | {
|
|
@@ -1219,51 +1562,65 @@ export declare class CamStreamerAPI<Client extends IClient<TResponse, any>> {
|
|
|
1219
1562
|
isActive: boolean;
|
|
1220
1563
|
}[];
|
|
1221
1564
|
};
|
|
1565
|
+
platform: "facebook";
|
|
1222
1566
|
deleteAfterEnd: boolean;
|
|
1223
|
-
saveToSdCard: boolean;
|
|
1224
|
-
statusCameraLed: boolean;
|
|
1225
|
-
statusCameraOutput: string | null;
|
|
1226
1567
|
countdown: boolean;
|
|
1227
1568
|
description?: string | undefined;
|
|
1228
1569
|
} | {
|
|
1229
|
-
|
|
1570
|
+
status: {
|
|
1571
|
+
port: number | null;
|
|
1572
|
+
led: boolean;
|
|
1573
|
+
};
|
|
1230
1574
|
audio: {
|
|
1231
|
-
source: "none";
|
|
1232
|
-
} | {
|
|
1233
1575
|
source: "microphone";
|
|
1234
1576
|
audioChannelNbr: 1 | 2;
|
|
1577
|
+
forceStereo: 0 | 1;
|
|
1235
1578
|
} | {
|
|
1236
1579
|
source: "file";
|
|
1580
|
+
forceStereo: 0 | 1;
|
|
1237
1581
|
fileName: string;
|
|
1238
1582
|
filePath: string;
|
|
1239
1583
|
} | {
|
|
1240
1584
|
source: "url";
|
|
1585
|
+
forceStereo: 0 | 1;
|
|
1241
1586
|
fileName: string;
|
|
1242
1587
|
fileUrl: string;
|
|
1243
1588
|
avSyncMsec: number;
|
|
1244
|
-
};
|
|
1589
|
+
} | null;
|
|
1245
1590
|
video: {
|
|
1246
|
-
|
|
1591
|
+
output: {
|
|
1592
|
+
type: "video" | "images";
|
|
1593
|
+
url: string;
|
|
1594
|
+
callApi: false;
|
|
1595
|
+
} | {
|
|
1596
|
+
type: "video";
|
|
1597
|
+
callApi: true;
|
|
1598
|
+
prepareAheadS: number;
|
|
1599
|
+
};
|
|
1600
|
+
outputParameters: string;
|
|
1601
|
+
input: {
|
|
1602
|
+
type: "RTSP_URL";
|
|
1603
|
+
url: string;
|
|
1604
|
+
} | {
|
|
1605
|
+
type: "CSw" | "CRS";
|
|
1606
|
+
};
|
|
1607
|
+
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
1247
1608
|
internalVapixParameters: string;
|
|
1248
1609
|
userVapixParameters: string;
|
|
1249
|
-
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
1250
|
-
sourceUrl?: string | undefined;
|
|
1251
1610
|
streamDelay?: {
|
|
1252
1611
|
value: number;
|
|
1253
1612
|
unit: "seconds" | "minutes" | "hours";
|
|
1254
1613
|
} | undefined;
|
|
1255
1614
|
};
|
|
1256
|
-
port: number;
|
|
1257
1615
|
enabled: boolean;
|
|
1258
|
-
|
|
1616
|
+
streamId: string;
|
|
1259
1617
|
active: boolean;
|
|
1260
1618
|
title: string;
|
|
1261
1619
|
trigger: {
|
|
1262
1620
|
type: "manual";
|
|
1263
|
-
ioPort:
|
|
1621
|
+
ioPort: number | null;
|
|
1264
1622
|
} | {
|
|
1265
1623
|
type: "onetime";
|
|
1266
|
-
ioPort: string | null;
|
|
1267
1624
|
startTime: number;
|
|
1268
1625
|
stopTime: number;
|
|
1269
1626
|
} | {
|
|
@@ -1280,59 +1637,62 @@ export declare class CamStreamerAPI<Client extends IClient<TResponse, any>> {
|
|
|
1280
1637
|
isActive: boolean;
|
|
1281
1638
|
}[];
|
|
1282
1639
|
};
|
|
1283
|
-
|
|
1284
|
-
statusCameraLed: boolean;
|
|
1285
|
-
statusCameraOutput: string | null;
|
|
1286
|
-
ipAddress: string;
|
|
1287
|
-
standard: "DVB" | "ATSC";
|
|
1288
|
-
nullPacketsPaddingEnabled: boolean;
|
|
1289
|
-
nullPacketsPaddingKbps: number;
|
|
1290
|
-
videoPid: number;
|
|
1291
|
-
audioPid: number;
|
|
1292
|
-
mpegtsStreamId: number;
|
|
1293
|
-
pmtPid: number;
|
|
1294
|
-
pcrPid: number;
|
|
1295
|
-
pcrPeriodMs: number;
|
|
1296
|
-
providerName: string;
|
|
1297
|
-
serviceName: string;
|
|
1640
|
+
platform: "windy";
|
|
1298
1641
|
} | {
|
|
1299
|
-
|
|
1642
|
+
status: {
|
|
1643
|
+
port: number | null;
|
|
1644
|
+
led: boolean;
|
|
1645
|
+
};
|
|
1300
1646
|
audio: {
|
|
1301
|
-
source: "none";
|
|
1302
|
-
} | {
|
|
1303
1647
|
source: "microphone";
|
|
1304
1648
|
audioChannelNbr: 1 | 2;
|
|
1649
|
+
forceStereo: 0 | 1;
|
|
1305
1650
|
} | {
|
|
1306
1651
|
source: "file";
|
|
1652
|
+
forceStereo: 0 | 1;
|
|
1307
1653
|
fileName: string;
|
|
1308
1654
|
filePath: string;
|
|
1309
1655
|
} | {
|
|
1310
1656
|
source: "url";
|
|
1657
|
+
forceStereo: 0 | 1;
|
|
1311
1658
|
fileName: string;
|
|
1312
1659
|
fileUrl: string;
|
|
1313
1660
|
avSyncMsec: number;
|
|
1314
|
-
};
|
|
1661
|
+
} | null;
|
|
1315
1662
|
video: {
|
|
1316
|
-
|
|
1663
|
+
output: {
|
|
1664
|
+
type: "video" | "images";
|
|
1665
|
+
url: string;
|
|
1666
|
+
callApi: false;
|
|
1667
|
+
} | {
|
|
1668
|
+
type: "video";
|
|
1669
|
+
callApi: true;
|
|
1670
|
+
prepareAheadS: number;
|
|
1671
|
+
};
|
|
1672
|
+
outputParameters: string;
|
|
1673
|
+
input: {
|
|
1674
|
+
type: "RTSP_URL";
|
|
1675
|
+
url: string;
|
|
1676
|
+
} | {
|
|
1677
|
+
type: "CSw" | "CRS";
|
|
1678
|
+
};
|
|
1679
|
+
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
1317
1680
|
internalVapixParameters: string;
|
|
1318
1681
|
userVapixParameters: string;
|
|
1319
|
-
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
1320
|
-
sourceUrl?: string | undefined;
|
|
1321
1682
|
streamDelay?: {
|
|
1322
1683
|
value: number;
|
|
1323
1684
|
unit: "seconds" | "minutes" | "hours";
|
|
1324
1685
|
} | undefined;
|
|
1325
1686
|
};
|
|
1326
1687
|
enabled: boolean;
|
|
1327
|
-
|
|
1688
|
+
streamId: string;
|
|
1328
1689
|
active: boolean;
|
|
1329
1690
|
title: string;
|
|
1330
1691
|
trigger: {
|
|
1331
1692
|
type: "manual";
|
|
1332
|
-
ioPort:
|
|
1693
|
+
ioPort: number | null;
|
|
1333
1694
|
} | {
|
|
1334
1695
|
type: "onetime";
|
|
1335
|
-
ioPort: string | null;
|
|
1336
1696
|
startTime: number;
|
|
1337
1697
|
stopTime: number;
|
|
1338
1698
|
} | {
|
|
@@ -1349,50 +1709,73 @@ export declare class CamStreamerAPI<Client extends IClient<TResponse, any>> {
|
|
|
1349
1709
|
isActive: boolean;
|
|
1350
1710
|
}[];
|
|
1351
1711
|
};
|
|
1352
|
-
|
|
1353
|
-
|
|
1354
|
-
|
|
1355
|
-
|
|
1356
|
-
|
|
1357
|
-
|
|
1712
|
+
streamPrivacy: "public" | "unlisted" | "private";
|
|
1713
|
+
platform: "youtube";
|
|
1714
|
+
countdown: boolean;
|
|
1715
|
+
tags: string[];
|
|
1716
|
+
latency: "normal" | "low" | "ultra_low";
|
|
1717
|
+
afterEndStatus: "public" | "unlisted" | "private" | "no_change";
|
|
1718
|
+
dvr: boolean;
|
|
1719
|
+
hasWatchdogs: boolean;
|
|
1720
|
+
enableManualControl: boolean;
|
|
1721
|
+
playlist?: string | undefined;
|
|
1722
|
+
description?: string | undefined;
|
|
1723
|
+
notificationEmail?: string[] | undefined;
|
|
1358
1724
|
} | {
|
|
1359
|
-
|
|
1725
|
+
status: {
|
|
1726
|
+
port: number | null;
|
|
1727
|
+
led: boolean;
|
|
1728
|
+
};
|
|
1360
1729
|
audio: {
|
|
1361
|
-
source: "none";
|
|
1362
|
-
} | {
|
|
1363
1730
|
source: "microphone";
|
|
1364
1731
|
audioChannelNbr: 1 | 2;
|
|
1732
|
+
forceStereo: 0 | 1;
|
|
1365
1733
|
} | {
|
|
1366
1734
|
source: "file";
|
|
1735
|
+
forceStereo: 0 | 1;
|
|
1367
1736
|
fileName: string;
|
|
1368
1737
|
filePath: string;
|
|
1369
1738
|
} | {
|
|
1370
1739
|
source: "url";
|
|
1740
|
+
forceStereo: 0 | 1;
|
|
1371
1741
|
fileName: string;
|
|
1372
1742
|
fileUrl: string;
|
|
1373
1743
|
avSyncMsec: number;
|
|
1374
|
-
};
|
|
1744
|
+
} | null;
|
|
1375
1745
|
video: {
|
|
1376
|
-
|
|
1746
|
+
output: {
|
|
1747
|
+
type: "video" | "images";
|
|
1748
|
+
url: string;
|
|
1749
|
+
callApi: false;
|
|
1750
|
+
} | {
|
|
1751
|
+
type: "video";
|
|
1752
|
+
callApi: true;
|
|
1753
|
+
prepareAheadS: number;
|
|
1754
|
+
};
|
|
1755
|
+
outputParameters: string;
|
|
1756
|
+
input: {
|
|
1757
|
+
type: "RTSP_URL";
|
|
1758
|
+
url: string;
|
|
1759
|
+
} | {
|
|
1760
|
+
type: "CSw" | "CRS";
|
|
1761
|
+
};
|
|
1762
|
+
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
1377
1763
|
internalVapixParameters: string;
|
|
1378
1764
|
userVapixParameters: string;
|
|
1379
|
-
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
1380
|
-
sourceUrl?: string | undefined;
|
|
1381
1765
|
streamDelay?: {
|
|
1382
1766
|
value: number;
|
|
1383
1767
|
unit: "seconds" | "minutes" | "hours";
|
|
1384
1768
|
} | undefined;
|
|
1385
1769
|
};
|
|
1386
1770
|
enabled: boolean;
|
|
1387
|
-
|
|
1771
|
+
streamId: string;
|
|
1388
1772
|
active: boolean;
|
|
1389
1773
|
title: string;
|
|
1390
1774
|
trigger: {
|
|
1391
1775
|
type: "manual";
|
|
1392
|
-
ioPort:
|
|
1776
|
+
ioPort: number | null;
|
|
1393
1777
|
} | {
|
|
1394
1778
|
type: "onetime";
|
|
1395
|
-
ioPort: string | null;
|
|
1396
1779
|
startTime: number;
|
|
1397
1780
|
stopTime: number;
|
|
1398
1781
|
} | {
|
|
@@ -1409,44 +1792,62 @@ export declare class CamStreamerAPI<Client extends IClient<TResponse, any>> {
|
|
|
1409
1792
|
isActive: boolean;
|
|
1410
1793
|
}[];
|
|
1411
1794
|
};
|
|
1795
|
+
platform: "church";
|
|
1412
1796
|
} | {
|
|
1413
|
-
|
|
1797
|
+
status: {
|
|
1798
|
+
port: number | null;
|
|
1799
|
+
led: boolean;
|
|
1800
|
+
};
|
|
1414
1801
|
audio: {
|
|
1415
|
-
source: "none";
|
|
1416
|
-
} | {
|
|
1417
1802
|
source: "microphone";
|
|
1418
1803
|
audioChannelNbr: 1 | 2;
|
|
1804
|
+
forceStereo: 0 | 1;
|
|
1419
1805
|
} | {
|
|
1420
1806
|
source: "file";
|
|
1807
|
+
forceStereo: 0 | 1;
|
|
1421
1808
|
fileName: string;
|
|
1422
1809
|
filePath: string;
|
|
1423
1810
|
} | {
|
|
1424
1811
|
source: "url";
|
|
1812
|
+
forceStereo: 0 | 1;
|
|
1425
1813
|
fileName: string;
|
|
1426
1814
|
fileUrl: string;
|
|
1427
1815
|
avSyncMsec: number;
|
|
1428
|
-
};
|
|
1816
|
+
} | null;
|
|
1429
1817
|
video: {
|
|
1430
|
-
|
|
1818
|
+
output: {
|
|
1819
|
+
type: "video" | "images";
|
|
1820
|
+
url: string;
|
|
1821
|
+
callApi: false;
|
|
1822
|
+
} | {
|
|
1823
|
+
type: "video";
|
|
1824
|
+
callApi: true;
|
|
1825
|
+
prepareAheadS: number;
|
|
1826
|
+
};
|
|
1827
|
+
outputParameters: string;
|
|
1828
|
+
input: {
|
|
1829
|
+
type: "RTSP_URL";
|
|
1830
|
+
url: string;
|
|
1831
|
+
} | {
|
|
1832
|
+
type: "CSw" | "CRS";
|
|
1833
|
+
};
|
|
1834
|
+
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
1431
1835
|
internalVapixParameters: string;
|
|
1432
1836
|
userVapixParameters: string;
|
|
1433
|
-
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
1434
|
-
sourceUrl?: string | undefined;
|
|
1435
1837
|
streamDelay?: {
|
|
1436
1838
|
value: number;
|
|
1437
1839
|
unit: "seconds" | "minutes" | "hours";
|
|
1438
1840
|
} | undefined;
|
|
1439
1841
|
};
|
|
1440
1842
|
enabled: boolean;
|
|
1441
|
-
|
|
1843
|
+
streamId: string;
|
|
1442
1844
|
active: boolean;
|
|
1443
1845
|
title: string;
|
|
1444
1846
|
trigger: {
|
|
1445
1847
|
type: "manual";
|
|
1446
|
-
ioPort:
|
|
1848
|
+
ioPort: number | null;
|
|
1447
1849
|
} | {
|
|
1448
1850
|
type: "onetime";
|
|
1449
|
-
ioPort: string | null;
|
|
1450
1851
|
startTime: number;
|
|
1451
1852
|
stopTime: number;
|
|
1452
1853
|
} | {
|
|
@@ -1463,44 +1864,62 @@ export declare class CamStreamerAPI<Client extends IClient<TResponse, any>> {
|
|
|
1463
1864
|
isActive: boolean;
|
|
1464
1865
|
}[];
|
|
1465
1866
|
};
|
|
1867
|
+
platform: "da_cast";
|
|
1466
1868
|
} | {
|
|
1467
|
-
|
|
1869
|
+
status: {
|
|
1870
|
+
port: number | null;
|
|
1871
|
+
led: boolean;
|
|
1872
|
+
};
|
|
1468
1873
|
audio: {
|
|
1469
|
-
source: "none";
|
|
1470
|
-
} | {
|
|
1471
1874
|
source: "microphone";
|
|
1472
1875
|
audioChannelNbr: 1 | 2;
|
|
1876
|
+
forceStereo: 0 | 1;
|
|
1473
1877
|
} | {
|
|
1474
1878
|
source: "file";
|
|
1879
|
+
forceStereo: 0 | 1;
|
|
1475
1880
|
fileName: string;
|
|
1476
1881
|
filePath: string;
|
|
1477
1882
|
} | {
|
|
1478
1883
|
source: "url";
|
|
1884
|
+
forceStereo: 0 | 1;
|
|
1479
1885
|
fileName: string;
|
|
1480
1886
|
fileUrl: string;
|
|
1481
1887
|
avSyncMsec: number;
|
|
1482
|
-
};
|
|
1888
|
+
} | null;
|
|
1483
1889
|
video: {
|
|
1484
|
-
|
|
1890
|
+
output: {
|
|
1891
|
+
type: "video" | "images";
|
|
1892
|
+
url: string;
|
|
1893
|
+
callApi: false;
|
|
1894
|
+
} | {
|
|
1895
|
+
type: "video";
|
|
1896
|
+
callApi: true;
|
|
1897
|
+
prepareAheadS: number;
|
|
1898
|
+
};
|
|
1899
|
+
outputParameters: string;
|
|
1900
|
+
input: {
|
|
1901
|
+
type: "RTSP_URL";
|
|
1902
|
+
url: string;
|
|
1903
|
+
} | {
|
|
1904
|
+
type: "CSw" | "CRS";
|
|
1905
|
+
};
|
|
1906
|
+
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
1485
1907
|
internalVapixParameters: string;
|
|
1486
1908
|
userVapixParameters: string;
|
|
1487
|
-
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
1488
|
-
sourceUrl?: string | undefined;
|
|
1489
1909
|
streamDelay?: {
|
|
1490
1910
|
value: number;
|
|
1491
1911
|
unit: "seconds" | "minutes" | "hours";
|
|
1492
1912
|
} | undefined;
|
|
1493
1913
|
};
|
|
1494
1914
|
enabled: boolean;
|
|
1495
|
-
|
|
1915
|
+
streamId: string;
|
|
1496
1916
|
active: boolean;
|
|
1497
1917
|
title: string;
|
|
1498
1918
|
trigger: {
|
|
1499
1919
|
type: "manual";
|
|
1500
|
-
ioPort:
|
|
1920
|
+
ioPort: number | null;
|
|
1501
1921
|
} | {
|
|
1502
1922
|
type: "onetime";
|
|
1503
|
-
ioPort: string | null;
|
|
1504
1923
|
startTime: number;
|
|
1505
1924
|
stopTime: number;
|
|
1506
1925
|
} | {
|
|
@@ -1517,58 +1936,62 @@ export declare class CamStreamerAPI<Client extends IClient<TResponse, any>> {
|
|
|
1517
1936
|
isActive: boolean;
|
|
1518
1937
|
}[];
|
|
1519
1938
|
};
|
|
1520
|
-
|
|
1521
|
-
saveToSdCard: boolean;
|
|
1522
|
-
statusCameraLed: boolean;
|
|
1523
|
-
statusCameraOutput: string | null;
|
|
1524
|
-
countdown: boolean;
|
|
1525
|
-
tags: string[];
|
|
1526
|
-
latency: "normal" | "low" | "ultra_low";
|
|
1527
|
-
afterEndStatus: "public" | "unlisted" | "private" | "no_change";
|
|
1528
|
-
dvr: boolean;
|
|
1529
|
-
hasWatchdogs: boolean;
|
|
1530
|
-
enableManualControl: boolean;
|
|
1531
|
-
playlist?: string | undefined;
|
|
1532
|
-
description?: string | undefined;
|
|
1533
|
-
notificationEmail?: string[] | undefined;
|
|
1939
|
+
platform: "dailymotion";
|
|
1534
1940
|
} | {
|
|
1535
|
-
|
|
1941
|
+
status: {
|
|
1942
|
+
port: number | null;
|
|
1943
|
+
led: boolean;
|
|
1944
|
+
};
|
|
1536
1945
|
audio: {
|
|
1537
|
-
source: "none";
|
|
1538
|
-
} | {
|
|
1539
1946
|
source: "microphone";
|
|
1540
1947
|
audioChannelNbr: 1 | 2;
|
|
1948
|
+
forceStereo: 0 | 1;
|
|
1541
1949
|
} | {
|
|
1542
1950
|
source: "file";
|
|
1951
|
+
forceStereo: 0 | 1;
|
|
1543
1952
|
fileName: string;
|
|
1544
1953
|
filePath: string;
|
|
1545
1954
|
} | {
|
|
1546
1955
|
source: "url";
|
|
1956
|
+
forceStereo: 0 | 1;
|
|
1547
1957
|
fileName: string;
|
|
1548
1958
|
fileUrl: string;
|
|
1549
1959
|
avSyncMsec: number;
|
|
1550
|
-
};
|
|
1960
|
+
} | null;
|
|
1551
1961
|
video: {
|
|
1552
|
-
|
|
1962
|
+
output: {
|
|
1963
|
+
type: "video" | "images";
|
|
1964
|
+
url: string;
|
|
1965
|
+
callApi: false;
|
|
1966
|
+
} | {
|
|
1967
|
+
type: "video";
|
|
1968
|
+
callApi: true;
|
|
1969
|
+
prepareAheadS: number;
|
|
1970
|
+
};
|
|
1971
|
+
outputParameters: string;
|
|
1972
|
+
input: {
|
|
1973
|
+
type: "RTSP_URL";
|
|
1974
|
+
url: string;
|
|
1975
|
+
} | {
|
|
1976
|
+
type: "CSw" | "CRS";
|
|
1977
|
+
};
|
|
1978
|
+
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
1553
1979
|
internalVapixParameters: string;
|
|
1554
1980
|
userVapixParameters: string;
|
|
1555
|
-
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
1556
|
-
sourceUrl?: string | undefined;
|
|
1557
1981
|
streamDelay?: {
|
|
1558
1982
|
value: number;
|
|
1559
1983
|
unit: "seconds" | "minutes" | "hours";
|
|
1560
1984
|
} | undefined;
|
|
1561
1985
|
};
|
|
1562
1986
|
enabled: boolean;
|
|
1563
|
-
|
|
1987
|
+
streamId: string;
|
|
1564
1988
|
active: boolean;
|
|
1565
1989
|
title: string;
|
|
1566
1990
|
trigger: {
|
|
1567
1991
|
type: "manual";
|
|
1568
|
-
ioPort:
|
|
1992
|
+
ioPort: number | null;
|
|
1569
1993
|
} | {
|
|
1570
1994
|
type: "onetime";
|
|
1571
|
-
ioPort: string | null;
|
|
1572
1995
|
startTime: number;
|
|
1573
1996
|
stopTime: number;
|
|
1574
1997
|
} | {
|
|
@@ -1585,44 +2008,64 @@ export declare class CamStreamerAPI<Client extends IClient<TResponse, any>> {
|
|
|
1585
2008
|
isActive: boolean;
|
|
1586
2009
|
}[];
|
|
1587
2010
|
};
|
|
2011
|
+
platform: "game_changer";
|
|
2012
|
+
streamKey: string;
|
|
2013
|
+
streamIdentifier?: string | undefined;
|
|
1588
2014
|
} | {
|
|
1589
|
-
|
|
2015
|
+
status: {
|
|
2016
|
+
port: number | null;
|
|
2017
|
+
led: boolean;
|
|
2018
|
+
};
|
|
1590
2019
|
audio: {
|
|
1591
|
-
source: "none";
|
|
1592
|
-
} | {
|
|
1593
2020
|
source: "microphone";
|
|
1594
2021
|
audioChannelNbr: 1 | 2;
|
|
2022
|
+
forceStereo: 0 | 1;
|
|
1595
2023
|
} | {
|
|
1596
2024
|
source: "file";
|
|
2025
|
+
forceStereo: 0 | 1;
|
|
1597
2026
|
fileName: string;
|
|
1598
2027
|
filePath: string;
|
|
1599
2028
|
} | {
|
|
1600
2029
|
source: "url";
|
|
2030
|
+
forceStereo: 0 | 1;
|
|
1601
2031
|
fileName: string;
|
|
1602
2032
|
fileUrl: string;
|
|
1603
2033
|
avSyncMsec: number;
|
|
1604
|
-
};
|
|
2034
|
+
} | null;
|
|
1605
2035
|
video: {
|
|
1606
|
-
|
|
2036
|
+
output: {
|
|
2037
|
+
type: "video" | "images";
|
|
2038
|
+
url: string;
|
|
2039
|
+
callApi: false;
|
|
2040
|
+
} | {
|
|
2041
|
+
type: "video";
|
|
2042
|
+
callApi: true;
|
|
2043
|
+
prepareAheadS: number;
|
|
2044
|
+
};
|
|
2045
|
+
outputParameters: string;
|
|
2046
|
+
input: {
|
|
2047
|
+
type: "RTSP_URL";
|
|
2048
|
+
url: string;
|
|
2049
|
+
} | {
|
|
2050
|
+
type: "CSw" | "CRS";
|
|
2051
|
+
};
|
|
2052
|
+
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
1607
2053
|
internalVapixParameters: string;
|
|
1608
2054
|
userVapixParameters: string;
|
|
1609
|
-
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
1610
|
-
sourceUrl?: string | undefined;
|
|
1611
2055
|
streamDelay?: {
|
|
1612
2056
|
value: number;
|
|
1613
2057
|
unit: "seconds" | "minutes" | "hours";
|
|
1614
2058
|
} | undefined;
|
|
1615
2059
|
};
|
|
1616
2060
|
enabled: boolean;
|
|
1617
|
-
|
|
2061
|
+
streamId: string;
|
|
1618
2062
|
active: boolean;
|
|
1619
2063
|
title: string;
|
|
1620
2064
|
trigger: {
|
|
1621
2065
|
type: "manual";
|
|
1622
|
-
ioPort:
|
|
2066
|
+
ioPort: number | null;
|
|
1623
2067
|
} | {
|
|
1624
2068
|
type: "onetime";
|
|
1625
|
-
ioPort: string | null;
|
|
1626
2069
|
startTime: number;
|
|
1627
2070
|
stopTime: number;
|
|
1628
2071
|
} | {
|
|
@@ -1639,44 +2082,62 @@ export declare class CamStreamerAPI<Client extends IClient<TResponse, any>> {
|
|
|
1639
2082
|
isActive: boolean;
|
|
1640
2083
|
}[];
|
|
1641
2084
|
};
|
|
2085
|
+
platform: "hls_pull";
|
|
1642
2086
|
} | {
|
|
1643
|
-
|
|
2087
|
+
status: {
|
|
2088
|
+
port: number | null;
|
|
2089
|
+
led: boolean;
|
|
2090
|
+
};
|
|
1644
2091
|
audio: {
|
|
1645
|
-
source: "none";
|
|
1646
|
-
} | {
|
|
1647
2092
|
source: "microphone";
|
|
1648
2093
|
audioChannelNbr: 1 | 2;
|
|
2094
|
+
forceStereo: 0 | 1;
|
|
1649
2095
|
} | {
|
|
1650
2096
|
source: "file";
|
|
2097
|
+
forceStereo: 0 | 1;
|
|
1651
2098
|
fileName: string;
|
|
1652
2099
|
filePath: string;
|
|
1653
2100
|
} | {
|
|
1654
2101
|
source: "url";
|
|
2102
|
+
forceStereo: 0 | 1;
|
|
1655
2103
|
fileName: string;
|
|
1656
2104
|
fileUrl: string;
|
|
1657
2105
|
avSyncMsec: number;
|
|
1658
|
-
};
|
|
2106
|
+
} | null;
|
|
1659
2107
|
video: {
|
|
1660
|
-
|
|
2108
|
+
output: {
|
|
2109
|
+
type: "video" | "images";
|
|
2110
|
+
url: string;
|
|
2111
|
+
callApi: false;
|
|
2112
|
+
} | {
|
|
2113
|
+
type: "video";
|
|
2114
|
+
callApi: true;
|
|
2115
|
+
prepareAheadS: number;
|
|
2116
|
+
};
|
|
2117
|
+
outputParameters: string;
|
|
2118
|
+
input: {
|
|
2119
|
+
type: "RTSP_URL";
|
|
2120
|
+
url: string;
|
|
2121
|
+
} | {
|
|
2122
|
+
type: "CSw" | "CRS";
|
|
2123
|
+
};
|
|
2124
|
+
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
1661
2125
|
internalVapixParameters: string;
|
|
1662
2126
|
userVapixParameters: string;
|
|
1663
|
-
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
1664
|
-
sourceUrl?: string | undefined;
|
|
1665
2127
|
streamDelay?: {
|
|
1666
2128
|
value: number;
|
|
1667
2129
|
unit: "seconds" | "minutes" | "hours";
|
|
1668
2130
|
} | undefined;
|
|
1669
2131
|
};
|
|
1670
2132
|
enabled: boolean;
|
|
1671
|
-
|
|
2133
|
+
streamId: string;
|
|
1672
2134
|
active: boolean;
|
|
1673
2135
|
title: string;
|
|
1674
2136
|
trigger: {
|
|
1675
2137
|
type: "manual";
|
|
1676
|
-
ioPort:
|
|
2138
|
+
ioPort: number | null;
|
|
1677
2139
|
} | {
|
|
1678
2140
|
type: "onetime";
|
|
1679
|
-
ioPort: string | null;
|
|
1680
2141
|
startTime: number;
|
|
1681
2142
|
stopTime: number;
|
|
1682
2143
|
} | {
|
|
@@ -1693,44 +2154,62 @@ export declare class CamStreamerAPI<Client extends IClient<TResponse, any>> {
|
|
|
1693
2154
|
isActive: boolean;
|
|
1694
2155
|
}[];
|
|
1695
2156
|
};
|
|
2157
|
+
platform: "hls_push";
|
|
1696
2158
|
} | {
|
|
1697
|
-
|
|
2159
|
+
status: {
|
|
2160
|
+
port: number | null;
|
|
2161
|
+
led: boolean;
|
|
2162
|
+
};
|
|
1698
2163
|
audio: {
|
|
1699
|
-
source: "none";
|
|
1700
|
-
} | {
|
|
1701
2164
|
source: "microphone";
|
|
1702
2165
|
audioChannelNbr: 1 | 2;
|
|
2166
|
+
forceStereo: 0 | 1;
|
|
1703
2167
|
} | {
|
|
1704
2168
|
source: "file";
|
|
2169
|
+
forceStereo: 0 | 1;
|
|
1705
2170
|
fileName: string;
|
|
1706
2171
|
filePath: string;
|
|
1707
2172
|
} | {
|
|
1708
2173
|
source: "url";
|
|
2174
|
+
forceStereo: 0 | 1;
|
|
1709
2175
|
fileName: string;
|
|
1710
2176
|
fileUrl: string;
|
|
1711
2177
|
avSyncMsec: number;
|
|
1712
|
-
};
|
|
2178
|
+
} | null;
|
|
1713
2179
|
video: {
|
|
1714
|
-
|
|
2180
|
+
output: {
|
|
2181
|
+
type: "video" | "images";
|
|
2182
|
+
url: string;
|
|
2183
|
+
callApi: false;
|
|
2184
|
+
} | {
|
|
2185
|
+
type: "video";
|
|
2186
|
+
callApi: true;
|
|
2187
|
+
prepareAheadS: number;
|
|
2188
|
+
};
|
|
2189
|
+
outputParameters: string;
|
|
2190
|
+
input: {
|
|
2191
|
+
type: "RTSP_URL";
|
|
2192
|
+
url: string;
|
|
2193
|
+
} | {
|
|
2194
|
+
type: "CSw" | "CRS";
|
|
2195
|
+
};
|
|
2196
|
+
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
1715
2197
|
internalVapixParameters: string;
|
|
1716
2198
|
userVapixParameters: string;
|
|
1717
|
-
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
1718
|
-
sourceUrl?: string | undefined;
|
|
1719
2199
|
streamDelay?: {
|
|
1720
2200
|
value: number;
|
|
1721
2201
|
unit: "seconds" | "minutes" | "hours";
|
|
1722
2202
|
} | undefined;
|
|
1723
2203
|
};
|
|
1724
2204
|
enabled: boolean;
|
|
1725
|
-
|
|
2205
|
+
streamId: string;
|
|
1726
2206
|
active: boolean;
|
|
1727
2207
|
title: string;
|
|
1728
2208
|
trigger: {
|
|
1729
2209
|
type: "manual";
|
|
1730
|
-
ioPort:
|
|
2210
|
+
ioPort: number | null;
|
|
1731
2211
|
} | {
|
|
1732
2212
|
type: "onetime";
|
|
1733
|
-
ioPort: string | null;
|
|
1734
2213
|
startTime: number;
|
|
1735
2214
|
stopTime: number;
|
|
1736
2215
|
} | {
|
|
@@ -1747,44 +2226,62 @@ export declare class CamStreamerAPI<Client extends IClient<TResponse, any>> {
|
|
|
1747
2226
|
isActive: boolean;
|
|
1748
2227
|
}[];
|
|
1749
2228
|
};
|
|
2229
|
+
platform: "ibm";
|
|
1750
2230
|
} | {
|
|
1751
|
-
|
|
2231
|
+
status: {
|
|
2232
|
+
port: number | null;
|
|
2233
|
+
led: boolean;
|
|
2234
|
+
};
|
|
1752
2235
|
audio: {
|
|
1753
|
-
source: "none";
|
|
1754
|
-
} | {
|
|
1755
2236
|
source: "microphone";
|
|
1756
2237
|
audioChannelNbr: 1 | 2;
|
|
2238
|
+
forceStereo: 0 | 1;
|
|
1757
2239
|
} | {
|
|
1758
2240
|
source: "file";
|
|
2241
|
+
forceStereo: 0 | 1;
|
|
1759
2242
|
fileName: string;
|
|
1760
2243
|
filePath: string;
|
|
1761
2244
|
} | {
|
|
1762
2245
|
source: "url";
|
|
2246
|
+
forceStereo: 0 | 1;
|
|
1763
2247
|
fileName: string;
|
|
1764
2248
|
fileUrl: string;
|
|
1765
2249
|
avSyncMsec: number;
|
|
1766
|
-
};
|
|
2250
|
+
} | null;
|
|
1767
2251
|
video: {
|
|
1768
|
-
|
|
2252
|
+
output: {
|
|
2253
|
+
type: "video" | "images";
|
|
2254
|
+
url: string;
|
|
2255
|
+
callApi: false;
|
|
2256
|
+
} | {
|
|
2257
|
+
type: "video";
|
|
2258
|
+
callApi: true;
|
|
2259
|
+
prepareAheadS: number;
|
|
2260
|
+
};
|
|
2261
|
+
outputParameters: string;
|
|
2262
|
+
input: {
|
|
2263
|
+
type: "RTSP_URL";
|
|
2264
|
+
url: string;
|
|
2265
|
+
} | {
|
|
2266
|
+
type: "CSw" | "CRS";
|
|
2267
|
+
};
|
|
2268
|
+
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
1769
2269
|
internalVapixParameters: string;
|
|
1770
2270
|
userVapixParameters: string;
|
|
1771
|
-
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
1772
|
-
sourceUrl?: string | undefined;
|
|
1773
2271
|
streamDelay?: {
|
|
1774
2272
|
value: number;
|
|
1775
2273
|
unit: "seconds" | "minutes" | "hours";
|
|
1776
2274
|
} | undefined;
|
|
1777
2275
|
};
|
|
1778
2276
|
enabled: boolean;
|
|
1779
|
-
|
|
2277
|
+
streamId: string;
|
|
1780
2278
|
active: boolean;
|
|
1781
2279
|
title: string;
|
|
1782
2280
|
trigger: {
|
|
1783
2281
|
type: "manual";
|
|
1784
|
-
ioPort:
|
|
2282
|
+
ioPort: number | null;
|
|
1785
2283
|
} | {
|
|
1786
2284
|
type: "onetime";
|
|
1787
|
-
ioPort: string | null;
|
|
1788
2285
|
startTime: number;
|
|
1789
2286
|
stopTime: number;
|
|
1790
2287
|
} | {
|
|
@@ -1801,44 +2298,62 @@ export declare class CamStreamerAPI<Client extends IClient<TResponse, any>> {
|
|
|
1801
2298
|
isActive: boolean;
|
|
1802
2299
|
}[];
|
|
1803
2300
|
};
|
|
2301
|
+
platform: "mpeg_dvb";
|
|
1804
2302
|
} | {
|
|
1805
|
-
|
|
2303
|
+
status: {
|
|
2304
|
+
port: number | null;
|
|
2305
|
+
led: boolean;
|
|
2306
|
+
};
|
|
1806
2307
|
audio: {
|
|
1807
|
-
source: "none";
|
|
1808
|
-
} | {
|
|
1809
2308
|
source: "microphone";
|
|
1810
2309
|
audioChannelNbr: 1 | 2;
|
|
2310
|
+
forceStereo: 0 | 1;
|
|
1811
2311
|
} | {
|
|
1812
2312
|
source: "file";
|
|
2313
|
+
forceStereo: 0 | 1;
|
|
1813
2314
|
fileName: string;
|
|
1814
2315
|
filePath: string;
|
|
1815
2316
|
} | {
|
|
1816
2317
|
source: "url";
|
|
2318
|
+
forceStereo: 0 | 1;
|
|
1817
2319
|
fileName: string;
|
|
1818
2320
|
fileUrl: string;
|
|
1819
2321
|
avSyncMsec: number;
|
|
1820
|
-
};
|
|
2322
|
+
} | null;
|
|
1821
2323
|
video: {
|
|
1822
|
-
|
|
2324
|
+
output: {
|
|
2325
|
+
type: "video" | "images";
|
|
2326
|
+
url: string;
|
|
2327
|
+
callApi: false;
|
|
2328
|
+
} | {
|
|
2329
|
+
type: "video";
|
|
2330
|
+
callApi: true;
|
|
2331
|
+
prepareAheadS: number;
|
|
2332
|
+
};
|
|
2333
|
+
outputParameters: string;
|
|
2334
|
+
input: {
|
|
2335
|
+
type: "RTSP_URL";
|
|
2336
|
+
url: string;
|
|
2337
|
+
} | {
|
|
2338
|
+
type: "CSw" | "CRS";
|
|
2339
|
+
};
|
|
2340
|
+
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
1823
2341
|
internalVapixParameters: string;
|
|
1824
2342
|
userVapixParameters: string;
|
|
1825
|
-
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
1826
|
-
sourceUrl?: string | undefined;
|
|
1827
2343
|
streamDelay?: {
|
|
1828
2344
|
value: number;
|
|
1829
2345
|
unit: "seconds" | "minutes" | "hours";
|
|
1830
2346
|
} | undefined;
|
|
1831
2347
|
};
|
|
1832
2348
|
enabled: boolean;
|
|
1833
|
-
|
|
2349
|
+
streamId: string;
|
|
1834
2350
|
active: boolean;
|
|
1835
2351
|
title: string;
|
|
1836
2352
|
trigger: {
|
|
1837
2353
|
type: "manual";
|
|
1838
|
-
ioPort:
|
|
2354
|
+
ioPort: number | null;
|
|
1839
2355
|
} | {
|
|
1840
2356
|
type: "onetime";
|
|
1841
|
-
ioPort: string | null;
|
|
1842
2357
|
startTime: number;
|
|
1843
2358
|
stopTime: number;
|
|
1844
2359
|
} | {
|
|
@@ -1855,44 +2370,62 @@ export declare class CamStreamerAPI<Client extends IClient<TResponse, any>> {
|
|
|
1855
2370
|
isActive: boolean;
|
|
1856
2371
|
}[];
|
|
1857
2372
|
};
|
|
2373
|
+
platform: "microsoft_azure";
|
|
1858
2374
|
} | {
|
|
1859
|
-
|
|
2375
|
+
status: {
|
|
2376
|
+
port: number | null;
|
|
2377
|
+
led: boolean;
|
|
2378
|
+
};
|
|
1860
2379
|
audio: {
|
|
1861
|
-
source: "none";
|
|
1862
|
-
} | {
|
|
1863
2380
|
source: "microphone";
|
|
1864
2381
|
audioChannelNbr: 1 | 2;
|
|
2382
|
+
forceStereo: 0 | 1;
|
|
1865
2383
|
} | {
|
|
1866
2384
|
source: "file";
|
|
2385
|
+
forceStereo: 0 | 1;
|
|
1867
2386
|
fileName: string;
|
|
1868
2387
|
filePath: string;
|
|
1869
2388
|
} | {
|
|
1870
2389
|
source: "url";
|
|
2390
|
+
forceStereo: 0 | 1;
|
|
1871
2391
|
fileName: string;
|
|
1872
2392
|
fileUrl: string;
|
|
1873
2393
|
avSyncMsec: number;
|
|
1874
|
-
};
|
|
2394
|
+
} | null;
|
|
1875
2395
|
video: {
|
|
1876
|
-
|
|
2396
|
+
output: {
|
|
2397
|
+
type: "video" | "images";
|
|
2398
|
+
url: string;
|
|
2399
|
+
callApi: false;
|
|
2400
|
+
} | {
|
|
2401
|
+
type: "video";
|
|
2402
|
+
callApi: true;
|
|
2403
|
+
prepareAheadS: number;
|
|
2404
|
+
};
|
|
2405
|
+
outputParameters: string;
|
|
2406
|
+
input: {
|
|
2407
|
+
type: "RTSP_URL";
|
|
2408
|
+
url: string;
|
|
2409
|
+
} | {
|
|
2410
|
+
type: "CSw" | "CRS";
|
|
2411
|
+
};
|
|
2412
|
+
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
1877
2413
|
internalVapixParameters: string;
|
|
1878
2414
|
userVapixParameters: string;
|
|
1879
|
-
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
1880
|
-
sourceUrl?: string | undefined;
|
|
1881
2415
|
streamDelay?: {
|
|
1882
2416
|
value: number;
|
|
1883
2417
|
unit: "seconds" | "minutes" | "hours";
|
|
1884
2418
|
} | undefined;
|
|
1885
2419
|
};
|
|
1886
2420
|
enabled: boolean;
|
|
1887
|
-
|
|
2421
|
+
streamId: string;
|
|
1888
2422
|
active: boolean;
|
|
1889
2423
|
title: string;
|
|
1890
2424
|
trigger: {
|
|
1891
2425
|
type: "manual";
|
|
1892
|
-
ioPort:
|
|
2426
|
+
ioPort: number | null;
|
|
1893
2427
|
} | {
|
|
1894
2428
|
type: "onetime";
|
|
1895
|
-
ioPort: string | null;
|
|
1896
2429
|
startTime: number;
|
|
1897
2430
|
stopTime: number;
|
|
1898
2431
|
} | {
|
|
@@ -1909,44 +2442,62 @@ export declare class CamStreamerAPI<Client extends IClient<TResponse, any>> {
|
|
|
1909
2442
|
isActive: boolean;
|
|
1910
2443
|
}[];
|
|
1911
2444
|
};
|
|
2445
|
+
platform: "microsoft_stream";
|
|
1912
2446
|
} | {
|
|
1913
|
-
|
|
2447
|
+
status: {
|
|
2448
|
+
port: number | null;
|
|
2449
|
+
led: boolean;
|
|
2450
|
+
};
|
|
1914
2451
|
audio: {
|
|
1915
|
-
source: "none";
|
|
1916
|
-
} | {
|
|
1917
2452
|
source: "microphone";
|
|
1918
2453
|
audioChannelNbr: 1 | 2;
|
|
2454
|
+
forceStereo: 0 | 1;
|
|
1919
2455
|
} | {
|
|
1920
2456
|
source: "file";
|
|
2457
|
+
forceStereo: 0 | 1;
|
|
1921
2458
|
fileName: string;
|
|
1922
2459
|
filePath: string;
|
|
1923
2460
|
} | {
|
|
1924
2461
|
source: "url";
|
|
2462
|
+
forceStereo: 0 | 1;
|
|
1925
2463
|
fileName: string;
|
|
1926
2464
|
fileUrl: string;
|
|
1927
2465
|
avSyncMsec: number;
|
|
1928
|
-
};
|
|
2466
|
+
} | null;
|
|
1929
2467
|
video: {
|
|
1930
|
-
|
|
2468
|
+
output: {
|
|
2469
|
+
type: "video" | "images";
|
|
2470
|
+
url: string;
|
|
2471
|
+
callApi: false;
|
|
2472
|
+
} | {
|
|
2473
|
+
type: "video";
|
|
2474
|
+
callApi: true;
|
|
2475
|
+
prepareAheadS: number;
|
|
2476
|
+
};
|
|
2477
|
+
outputParameters: string;
|
|
2478
|
+
input: {
|
|
2479
|
+
type: "RTSP_URL";
|
|
2480
|
+
url: string;
|
|
2481
|
+
} | {
|
|
2482
|
+
type: "CSw" | "CRS";
|
|
2483
|
+
};
|
|
2484
|
+
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
1931
2485
|
internalVapixParameters: string;
|
|
1932
2486
|
userVapixParameters: string;
|
|
1933
|
-
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
1934
|
-
sourceUrl?: string | undefined;
|
|
1935
2487
|
streamDelay?: {
|
|
1936
2488
|
value: number;
|
|
1937
2489
|
unit: "seconds" | "minutes" | "hours";
|
|
1938
2490
|
} | undefined;
|
|
1939
2491
|
};
|
|
1940
2492
|
enabled: boolean;
|
|
1941
|
-
|
|
2493
|
+
streamId: string;
|
|
1942
2494
|
active: boolean;
|
|
1943
2495
|
title: string;
|
|
1944
2496
|
trigger: {
|
|
1945
2497
|
type: "manual";
|
|
1946
|
-
ioPort:
|
|
2498
|
+
ioPort: number | null;
|
|
1947
2499
|
} | {
|
|
1948
2500
|
type: "onetime";
|
|
1949
|
-
ioPort: string | null;
|
|
1950
2501
|
startTime: number;
|
|
1951
2502
|
stopTime: number;
|
|
1952
2503
|
} | {
|
|
@@ -1963,44 +2514,64 @@ export declare class CamStreamerAPI<Client extends IClient<TResponse, any>> {
|
|
|
1963
2514
|
isActive: boolean;
|
|
1964
2515
|
}[];
|
|
1965
2516
|
};
|
|
2517
|
+
platform: "rtmp";
|
|
2518
|
+
streamKey: string;
|
|
2519
|
+
streamIdentifier?: string | undefined;
|
|
1966
2520
|
} | {
|
|
1967
|
-
|
|
2521
|
+
status: {
|
|
2522
|
+
port: number | null;
|
|
2523
|
+
led: boolean;
|
|
2524
|
+
};
|
|
1968
2525
|
audio: {
|
|
1969
|
-
source: "none";
|
|
1970
|
-
} | {
|
|
1971
2526
|
source: "microphone";
|
|
1972
2527
|
audioChannelNbr: 1 | 2;
|
|
2528
|
+
forceStereo: 0 | 1;
|
|
1973
2529
|
} | {
|
|
1974
2530
|
source: "file";
|
|
2531
|
+
forceStereo: 0 | 1;
|
|
1975
2532
|
fileName: string;
|
|
1976
2533
|
filePath: string;
|
|
1977
2534
|
} | {
|
|
1978
2535
|
source: "url";
|
|
2536
|
+
forceStereo: 0 | 1;
|
|
1979
2537
|
fileName: string;
|
|
1980
2538
|
fileUrl: string;
|
|
1981
2539
|
avSyncMsec: number;
|
|
1982
|
-
};
|
|
2540
|
+
} | null;
|
|
1983
2541
|
video: {
|
|
1984
|
-
|
|
2542
|
+
output: {
|
|
2543
|
+
type: "video" | "images";
|
|
2544
|
+
url: string;
|
|
2545
|
+
callApi: false;
|
|
2546
|
+
} | {
|
|
2547
|
+
type: "video";
|
|
2548
|
+
callApi: true;
|
|
2549
|
+
prepareAheadS: number;
|
|
2550
|
+
};
|
|
2551
|
+
outputParameters: string;
|
|
2552
|
+
input: {
|
|
2553
|
+
type: "RTSP_URL";
|
|
2554
|
+
url: string;
|
|
2555
|
+
} | {
|
|
2556
|
+
type: "CSw" | "CRS";
|
|
2557
|
+
};
|
|
2558
|
+
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
1985
2559
|
internalVapixParameters: string;
|
|
1986
2560
|
userVapixParameters: string;
|
|
1987
|
-
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
1988
|
-
sourceUrl?: string | undefined;
|
|
1989
2561
|
streamDelay?: {
|
|
1990
2562
|
value: number;
|
|
1991
2563
|
unit: "seconds" | "minutes" | "hours";
|
|
1992
2564
|
} | undefined;
|
|
1993
2565
|
};
|
|
1994
2566
|
enabled: boolean;
|
|
1995
|
-
|
|
2567
|
+
streamId: string;
|
|
1996
2568
|
active: boolean;
|
|
1997
2569
|
title: string;
|
|
1998
2570
|
trigger: {
|
|
1999
2571
|
type: "manual";
|
|
2000
|
-
ioPort:
|
|
2572
|
+
ioPort: number | null;
|
|
2001
2573
|
} | {
|
|
2002
2574
|
type: "onetime";
|
|
2003
|
-
ioPort: string | null;
|
|
2004
2575
|
startTime: number;
|
|
2005
2576
|
stopTime: number;
|
|
2006
2577
|
} | {
|
|
@@ -2017,44 +2588,62 @@ export declare class CamStreamerAPI<Client extends IClient<TResponse, any>> {
|
|
|
2017
2588
|
isActive: boolean;
|
|
2018
2589
|
}[];
|
|
2019
2590
|
};
|
|
2591
|
+
platform: "sd_card";
|
|
2020
2592
|
} | {
|
|
2021
|
-
|
|
2593
|
+
status: {
|
|
2594
|
+
port: number | null;
|
|
2595
|
+
led: boolean;
|
|
2596
|
+
};
|
|
2022
2597
|
audio: {
|
|
2023
|
-
source: "none";
|
|
2024
|
-
} | {
|
|
2025
2598
|
source: "microphone";
|
|
2026
2599
|
audioChannelNbr: 1 | 2;
|
|
2600
|
+
forceStereo: 0 | 1;
|
|
2027
2601
|
} | {
|
|
2028
2602
|
source: "file";
|
|
2603
|
+
forceStereo: 0 | 1;
|
|
2029
2604
|
fileName: string;
|
|
2030
2605
|
filePath: string;
|
|
2031
2606
|
} | {
|
|
2032
2607
|
source: "url";
|
|
2608
|
+
forceStereo: 0 | 1;
|
|
2033
2609
|
fileName: string;
|
|
2034
2610
|
fileUrl: string;
|
|
2035
2611
|
avSyncMsec: number;
|
|
2036
|
-
};
|
|
2612
|
+
} | null;
|
|
2037
2613
|
video: {
|
|
2038
|
-
|
|
2614
|
+
output: {
|
|
2615
|
+
type: "video" | "images";
|
|
2616
|
+
url: string;
|
|
2617
|
+
callApi: false;
|
|
2618
|
+
} | {
|
|
2619
|
+
type: "video";
|
|
2620
|
+
callApi: true;
|
|
2621
|
+
prepareAheadS: number;
|
|
2622
|
+
};
|
|
2623
|
+
outputParameters: string;
|
|
2624
|
+
input: {
|
|
2625
|
+
type: "RTSP_URL";
|
|
2626
|
+
url: string;
|
|
2627
|
+
} | {
|
|
2628
|
+
type: "CSw" | "CRS";
|
|
2629
|
+
};
|
|
2630
|
+
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
2039
2631
|
internalVapixParameters: string;
|
|
2040
2632
|
userVapixParameters: string;
|
|
2041
|
-
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
2042
|
-
sourceUrl?: string | undefined;
|
|
2043
2633
|
streamDelay?: {
|
|
2044
2634
|
value: number;
|
|
2045
2635
|
unit: "seconds" | "minutes" | "hours";
|
|
2046
2636
|
} | undefined;
|
|
2047
2637
|
};
|
|
2048
2638
|
enabled: boolean;
|
|
2049
|
-
|
|
2639
|
+
streamId: string;
|
|
2050
2640
|
active: boolean;
|
|
2051
2641
|
title: string;
|
|
2052
2642
|
trigger: {
|
|
2053
2643
|
type: "manual";
|
|
2054
|
-
ioPort:
|
|
2644
|
+
ioPort: number | null;
|
|
2055
2645
|
} | {
|
|
2056
2646
|
type: "onetime";
|
|
2057
|
-
ioPort: string | null;
|
|
2058
2647
|
startTime: number;
|
|
2059
2648
|
stopTime: number;
|
|
2060
2649
|
} | {
|
|
@@ -2071,44 +2660,62 @@ export declare class CamStreamerAPI<Client extends IClient<TResponse, any>> {
|
|
|
2071
2660
|
isActive: boolean;
|
|
2072
2661
|
}[];
|
|
2073
2662
|
};
|
|
2663
|
+
platform: "srt";
|
|
2074
2664
|
} | {
|
|
2075
|
-
|
|
2665
|
+
status: {
|
|
2666
|
+
port: number | null;
|
|
2667
|
+
led: boolean;
|
|
2668
|
+
};
|
|
2076
2669
|
audio: {
|
|
2077
|
-
source: "none";
|
|
2078
|
-
} | {
|
|
2079
2670
|
source: "microphone";
|
|
2080
2671
|
audioChannelNbr: 1 | 2;
|
|
2672
|
+
forceStereo: 0 | 1;
|
|
2081
2673
|
} | {
|
|
2082
2674
|
source: "file";
|
|
2675
|
+
forceStereo: 0 | 1;
|
|
2083
2676
|
fileName: string;
|
|
2084
2677
|
filePath: string;
|
|
2085
2678
|
} | {
|
|
2086
2679
|
source: "url";
|
|
2680
|
+
forceStereo: 0 | 1;
|
|
2087
2681
|
fileName: string;
|
|
2088
2682
|
fileUrl: string;
|
|
2089
2683
|
avSyncMsec: number;
|
|
2090
|
-
};
|
|
2684
|
+
} | null;
|
|
2091
2685
|
video: {
|
|
2092
|
-
|
|
2686
|
+
output: {
|
|
2687
|
+
type: "video" | "images";
|
|
2688
|
+
url: string;
|
|
2689
|
+
callApi: false;
|
|
2690
|
+
} | {
|
|
2691
|
+
type: "video";
|
|
2692
|
+
callApi: true;
|
|
2693
|
+
prepareAheadS: number;
|
|
2694
|
+
};
|
|
2695
|
+
outputParameters: string;
|
|
2696
|
+
input: {
|
|
2697
|
+
type: "RTSP_URL";
|
|
2698
|
+
url: string;
|
|
2699
|
+
} | {
|
|
2700
|
+
type: "CSw" | "CRS";
|
|
2701
|
+
};
|
|
2702
|
+
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
2093
2703
|
internalVapixParameters: string;
|
|
2094
2704
|
userVapixParameters: string;
|
|
2095
|
-
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
2096
|
-
sourceUrl?: string | undefined;
|
|
2097
2705
|
streamDelay?: {
|
|
2098
2706
|
value: number;
|
|
2099
2707
|
unit: "seconds" | "minutes" | "hours";
|
|
2100
2708
|
} | undefined;
|
|
2101
2709
|
};
|
|
2102
2710
|
enabled: boolean;
|
|
2103
|
-
|
|
2711
|
+
streamId: string;
|
|
2104
2712
|
active: boolean;
|
|
2105
2713
|
title: string;
|
|
2106
2714
|
trigger: {
|
|
2107
2715
|
type: "manual";
|
|
2108
|
-
ioPort:
|
|
2716
|
+
ioPort: number | null;
|
|
2109
2717
|
} | {
|
|
2110
2718
|
type: "onetime";
|
|
2111
|
-
ioPort: string | null;
|
|
2112
2719
|
startTime: number;
|
|
2113
2720
|
stopTime: number;
|
|
2114
2721
|
} | {
|
|
@@ -2125,44 +2732,62 @@ export declare class CamStreamerAPI<Client extends IClient<TResponse, any>> {
|
|
|
2125
2732
|
isActive: boolean;
|
|
2126
2733
|
}[];
|
|
2127
2734
|
};
|
|
2735
|
+
platform: "twitch";
|
|
2128
2736
|
} | {
|
|
2129
|
-
|
|
2737
|
+
status: {
|
|
2738
|
+
port: number | null;
|
|
2739
|
+
led: boolean;
|
|
2740
|
+
};
|
|
2130
2741
|
audio: {
|
|
2131
|
-
source: "none";
|
|
2132
|
-
} | {
|
|
2133
2742
|
source: "microphone";
|
|
2134
2743
|
audioChannelNbr: 1 | 2;
|
|
2744
|
+
forceStereo: 0 | 1;
|
|
2135
2745
|
} | {
|
|
2136
2746
|
source: "file";
|
|
2747
|
+
forceStereo: 0 | 1;
|
|
2137
2748
|
fileName: string;
|
|
2138
2749
|
filePath: string;
|
|
2139
2750
|
} | {
|
|
2140
2751
|
source: "url";
|
|
2752
|
+
forceStereo: 0 | 1;
|
|
2141
2753
|
fileName: string;
|
|
2142
2754
|
fileUrl: string;
|
|
2143
2755
|
avSyncMsec: number;
|
|
2144
|
-
};
|
|
2756
|
+
} | null;
|
|
2145
2757
|
video: {
|
|
2146
|
-
|
|
2758
|
+
output: {
|
|
2759
|
+
type: "video" | "images";
|
|
2760
|
+
url: string;
|
|
2761
|
+
callApi: false;
|
|
2762
|
+
} | {
|
|
2763
|
+
type: "video";
|
|
2764
|
+
callApi: true;
|
|
2765
|
+
prepareAheadS: number;
|
|
2766
|
+
};
|
|
2767
|
+
outputParameters: string;
|
|
2768
|
+
input: {
|
|
2769
|
+
type: "RTSP_URL";
|
|
2770
|
+
url: string;
|
|
2771
|
+
} | {
|
|
2772
|
+
type: "CSw" | "CRS";
|
|
2773
|
+
};
|
|
2774
|
+
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
2147
2775
|
internalVapixParameters: string;
|
|
2148
2776
|
userVapixParameters: string;
|
|
2149
|
-
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
2150
|
-
sourceUrl?: string | undefined;
|
|
2151
2777
|
streamDelay?: {
|
|
2152
2778
|
value: number;
|
|
2153
2779
|
unit: "seconds" | "minutes" | "hours";
|
|
2154
2780
|
} | undefined;
|
|
2155
2781
|
};
|
|
2156
2782
|
enabled: boolean;
|
|
2157
|
-
|
|
2783
|
+
streamId: string;
|
|
2158
2784
|
active: boolean;
|
|
2159
2785
|
title: string;
|
|
2160
2786
|
trigger: {
|
|
2161
2787
|
type: "manual";
|
|
2162
|
-
ioPort:
|
|
2788
|
+
ioPort: number | null;
|
|
2163
2789
|
} | {
|
|
2164
2790
|
type: "onetime";
|
|
2165
|
-
ioPort: string | null;
|
|
2166
2791
|
startTime: number;
|
|
2167
2792
|
stopTime: number;
|
|
2168
2793
|
} | {
|
|
@@ -2179,44 +2804,62 @@ export declare class CamStreamerAPI<Client extends IClient<TResponse, any>> {
|
|
|
2179
2804
|
isActive: boolean;
|
|
2180
2805
|
}[];
|
|
2181
2806
|
};
|
|
2807
|
+
platform: "vimeo";
|
|
2182
2808
|
} | {
|
|
2183
|
-
|
|
2809
|
+
status: {
|
|
2810
|
+
port: number | null;
|
|
2811
|
+
led: boolean;
|
|
2812
|
+
};
|
|
2184
2813
|
audio: {
|
|
2185
|
-
source: "none";
|
|
2186
|
-
} | {
|
|
2187
2814
|
source: "microphone";
|
|
2188
2815
|
audioChannelNbr: 1 | 2;
|
|
2816
|
+
forceStereo: 0 | 1;
|
|
2189
2817
|
} | {
|
|
2190
2818
|
source: "file";
|
|
2819
|
+
forceStereo: 0 | 1;
|
|
2191
2820
|
fileName: string;
|
|
2192
2821
|
filePath: string;
|
|
2193
2822
|
} | {
|
|
2194
2823
|
source: "url";
|
|
2824
|
+
forceStereo: 0 | 1;
|
|
2195
2825
|
fileName: string;
|
|
2196
2826
|
fileUrl: string;
|
|
2197
2827
|
avSyncMsec: number;
|
|
2198
|
-
};
|
|
2828
|
+
} | null;
|
|
2199
2829
|
video: {
|
|
2200
|
-
|
|
2830
|
+
output: {
|
|
2831
|
+
type: "video" | "images";
|
|
2832
|
+
url: string;
|
|
2833
|
+
callApi: false;
|
|
2834
|
+
} | {
|
|
2835
|
+
type: "video";
|
|
2836
|
+
callApi: true;
|
|
2837
|
+
prepareAheadS: number;
|
|
2838
|
+
};
|
|
2839
|
+
outputParameters: string;
|
|
2840
|
+
input: {
|
|
2841
|
+
type: "RTSP_URL";
|
|
2842
|
+
url: string;
|
|
2843
|
+
} | {
|
|
2844
|
+
type: "CSw" | "CRS";
|
|
2845
|
+
};
|
|
2846
|
+
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
2201
2847
|
internalVapixParameters: string;
|
|
2202
2848
|
userVapixParameters: string;
|
|
2203
|
-
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
2204
|
-
sourceUrl?: string | undefined;
|
|
2205
2849
|
streamDelay?: {
|
|
2206
2850
|
value: number;
|
|
2207
2851
|
unit: "seconds" | "minutes" | "hours";
|
|
2208
2852
|
} | undefined;
|
|
2209
2853
|
};
|
|
2210
2854
|
enabled: boolean;
|
|
2211
|
-
|
|
2855
|
+
streamId: string;
|
|
2212
2856
|
active: boolean;
|
|
2213
2857
|
title: string;
|
|
2214
2858
|
trigger: {
|
|
2215
2859
|
type: "manual";
|
|
2216
|
-
ioPort:
|
|
2860
|
+
ioPort: number | null;
|
|
2217
2861
|
} | {
|
|
2218
2862
|
type: "onetime";
|
|
2219
|
-
ioPort: string | null;
|
|
2220
2863
|
startTime: number;
|
|
2221
2864
|
stopTime: number;
|
|
2222
2865
|
} | {
|
|
@@ -2233,50 +2876,62 @@ export declare class CamStreamerAPI<Client extends IClient<TResponse, any>> {
|
|
|
2233
2876
|
isActive: boolean;
|
|
2234
2877
|
}[];
|
|
2235
2878
|
};
|
|
2236
|
-
|
|
2237
|
-
statusCameraLed: boolean;
|
|
2238
|
-
statusCameraOutput: string | null;
|
|
2239
|
-
outputUrl: string;
|
|
2240
|
-
streamKey: string;
|
|
2241
|
-
streamIdentifier?: string | undefined;
|
|
2879
|
+
platform: "wowza";
|
|
2242
2880
|
} | {
|
|
2243
|
-
|
|
2881
|
+
status: {
|
|
2882
|
+
port: number | null;
|
|
2883
|
+
led: boolean;
|
|
2884
|
+
};
|
|
2244
2885
|
audio: {
|
|
2245
|
-
source: "none";
|
|
2246
|
-
} | {
|
|
2247
2886
|
source: "microphone";
|
|
2248
2887
|
audioChannelNbr: 1 | 2;
|
|
2888
|
+
forceStereo: 0 | 1;
|
|
2249
2889
|
} | {
|
|
2250
2890
|
source: "file";
|
|
2891
|
+
forceStereo: 0 | 1;
|
|
2251
2892
|
fileName: string;
|
|
2252
2893
|
filePath: string;
|
|
2253
2894
|
} | {
|
|
2254
2895
|
source: "url";
|
|
2896
|
+
forceStereo: 0 | 1;
|
|
2255
2897
|
fileName: string;
|
|
2256
2898
|
fileUrl: string;
|
|
2257
2899
|
avSyncMsec: number;
|
|
2258
|
-
};
|
|
2900
|
+
} | null;
|
|
2259
2901
|
video: {
|
|
2260
|
-
|
|
2902
|
+
output: {
|
|
2903
|
+
type: "video" | "images";
|
|
2904
|
+
url: string;
|
|
2905
|
+
callApi: false;
|
|
2906
|
+
} | {
|
|
2907
|
+
type: "video";
|
|
2908
|
+
callApi: true;
|
|
2909
|
+
prepareAheadS: number;
|
|
2910
|
+
};
|
|
2911
|
+
outputParameters: string;
|
|
2912
|
+
input: {
|
|
2913
|
+
type: "RTSP_URL";
|
|
2914
|
+
url: string;
|
|
2915
|
+
} | {
|
|
2916
|
+
type: "CSw" | "CRS";
|
|
2917
|
+
};
|
|
2918
|
+
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
2261
2919
|
internalVapixParameters: string;
|
|
2262
2920
|
userVapixParameters: string;
|
|
2263
|
-
streamingProtocol: "RTMP" | "RTMPS" | "HLS_PUSH";
|
|
2264
|
-
sourceUrl?: string | undefined;
|
|
2265
2921
|
streamDelay?: {
|
|
2266
2922
|
value: number;
|
|
2267
2923
|
unit: "seconds" | "minutes" | "hours";
|
|
2268
2924
|
} | undefined;
|
|
2269
2925
|
};
|
|
2270
2926
|
enabled: boolean;
|
|
2271
|
-
|
|
2927
|
+
streamId: string;
|
|
2272
2928
|
active: boolean;
|
|
2273
2929
|
title: string;
|
|
2274
2930
|
trigger: {
|
|
2275
2931
|
type: "manual";
|
|
2276
|
-
ioPort:
|
|
2932
|
+
ioPort: number | null;
|
|
2277
2933
|
} | {
|
|
2278
2934
|
type: "onetime";
|
|
2279
|
-
ioPort: string | null;
|
|
2280
2935
|
startTime: number;
|
|
2281
2936
|
stopTime: number;
|
|
2282
2937
|
} | {
|
|
@@ -2293,17 +2948,14 @@ export declare class CamStreamerAPI<Client extends IClient<TResponse, any>> {
|
|
|
2293
2948
|
isActive: boolean;
|
|
2294
2949
|
}[];
|
|
2295
2950
|
};
|
|
2296
|
-
|
|
2297
|
-
statusCameraLed: boolean;
|
|
2298
|
-
statusCameraOutput: string | null;
|
|
2299
|
-
outputUrl: string;
|
|
2951
|
+
platform: "youtube_rtmp";
|
|
2300
2952
|
streamKey: string;
|
|
2301
2953
|
streamIdentifier?: string | undefined;
|
|
2302
2954
|
}>;
|
|
2303
|
-
setStream(streamId:
|
|
2304
|
-
isStreaming(streamId:
|
|
2305
|
-
setStreamEnabled(streamId:
|
|
2306
|
-
setStreamActive(streamId:
|
|
2955
|
+
setStream(streamId: string, streamData: TStream, options?: THttpRequestOptions): Promise<void>;
|
|
2956
|
+
isStreaming(streamId: string, options?: THttpRequestOptions): Promise<boolean>;
|
|
2957
|
+
setStreamEnabled(streamId: string, enabled: boolean, options?: THttpRequestOptions): Promise<void>;
|
|
2958
|
+
setStreamActive(streamId: string, active: boolean, options?: THttpRequestOptions): Promise<void>;
|
|
2307
2959
|
listFiles(options?: THttpRequestOptions): Promise<{
|
|
2308
2960
|
path: string;
|
|
2309
2961
|
name: string;
|