camstreamerlib 4.0.0-beta.29 → 4.0.0-beta.30

package/esm/VapixAPI.js

@@ -7,48 +7,56 @@ import { z } from 'zod';
 import { XMLParser } from 'fast-xml-parser';
 export class VapixAPI {
     client;
-    constructor(client, getProxyUrl) {
-        this.client = new ProxyClient(client, getProxyUrl);
+    constructor(client) {
+        this.client = client;
     }
-    async getUrlEncoded(proxy, path, parameters, headers = {}) {
+    async postUrlEncoded(path, parameters, headers, options) {
         const data = paramToUrl(parameters);
         const head = { ...headers, 'Content-Type': 'application/x-www-form-urlencoded' };
-        const res = await this.client.post(proxy, path, data, {}, head);
+        const agent = this.getAgent(options?.proxyParams);
+        const res = await agent.post({ path, data, headers: head, timeout: options?.timeout });
         if (!res.ok) {
             throw new Error(await responseStringify(res));
         }
         return res;
     }
-    async postJson(proxy, path, jsonData, headers = {}) {
+    async postJson(path, jsonData, headers, options) {
         const data = JSON.stringify(jsonData);
         const head = { ...headers, 'Content-Type': 'application/json' };
-        const res = await this.client.post(proxy, path, data, {}, head);
+        const agent = this.getAgent(options?.proxyParams);
+        const res = await agent.post({ path, data, headers: head, timeout: options?.timeout });
         if (!res.ok) {
             throw new Error(await responseStringify(res));
         }
         return res;
     }
-    async getCameraImage(params, proxy = null) {
-        return await this.client.get(proxy, '/axis-cgi/jpg/image.cgi', params);
+    async getCameraImage(parameters, options) {
+        const agent = this.getAgent(options?.proxyParams);
+        return await agent.get({ path: '/axis-cgi/jpg/image.cgi', parameters, timeout: options?.timeout });
     }
-    async getEventDeclarations(proxy = null) {
+    async getEventDeclarations(options) {
         const data = '<s:Envelope xmlns:s="http://www.w3.org/2003/05/soap-envelope">' +
             '<s:Body xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"' +
             'xmlns:xsd="http://www.w3.org/2001/XMLSchema">' +
             '<GetEventInstances xmlns="http://www.axis.com/vapix/ws/event1"/>' +
             '</s:Body>' +
             '</s:Envelope>';
-        const res = await this.client.post(proxy, '/vapix/services', data, { 'Content-Type': 'application/soap+xml' });
+        const agent = this.getAgent(options?.proxyParams);
+        const res = await agent.post({
+            path: '/vapix/services',
+            data,
+            headers: { 'Content-Type': 'application/soap+xml' },
+        });
         if (!res.ok) {
             throw new Error(await responseStringify(res));
         }
         const declarations = await res.text();
         return prettifyXml(declarations);
     }
-    async getSupportedAudioSampleRate(proxy = null) {
-        const url = '/axis-cgi/audio/streamingcapabilities.cgi';
+    async getSupportedAudioSampleRate(options) {
+        const path = '/axis-cgi/audio/streamingcapabilities.cgi';
         const jsonData = { apiVersion: '1.0', method: 'list' };
-        const res = await this.postJson(proxy, url, jsonData);
+        const res = await this.postJson(path, jsonData, undefined, options);
         const encoders = audioSampleRatesResponseSchema.parse(await res.json()).data.encoders;
         const data = encoders.aac ?? encoders.AAC ?? [];
         return data.map((item) => {
@@ -58,7 +66,7 @@ export class VapixAPI {
             };
         });
     }
-    async performAutofocus(proxy = null) {
+    async performAutofocus(options) {
         try {
             const data = {
                 apiVersion: '1',
@@ -71,19 +79,19 @@ export class VapixAPI {
                     ],
                 },
             };
-            await this.postJson(proxy, '/axis-cgi/opticscontrol.cgi', data);
+            await this.postJson('/axis-cgi/opticscontrol.cgi', data, undefined, options);
         }
         catch (err) {
-            await this.getUrlEncoded(proxy, '/axis-cgi/opticssetup.cgi', {
+            await this.postUrlEncoded('/axis-cgi/opticssetup.cgi', {
                 autofocus: 'perform',
                 source: '1',
-            });
+            }, undefined, options);
         }
     }
-    async checkSDCard(proxy = null) {
-        const res = await this.getUrlEncoded(proxy, '/axis-cgi/disks/list.cgi', {
+    async checkSDCard(options) {
+        const res = await this.postUrlEncoded('/axis-cgi/disks/list.cgi', {
             diskid: 'SD_DISK',
-        });
+        }, undefined, options);
         const xmlText = await res.text();
         const parser = new XMLParser({
             ignoreAttributes: false,
@@ -98,17 +106,17 @@ export class VapixAPI {
             status: sdCardWatchedStatuses.includes(data.status) ? data.status : 'disconnected',
         };
     }
-    mountSDCard(proxy = null) {
-        return this._doSDCardMountAction('MOUNT', proxy);
+    mountSDCard(options) {
+        return this._doSDCardMountAction('MOUNT', options);
     }
-    unmountSDCard(proxy = null) {
-        return this._doSDCardMountAction('UNMOUNT', proxy);
+    unmountSDCard(options) {
+        return this._doSDCardMountAction('UNMOUNT', options);
     }
-    async _doSDCardMountAction(action, proxy = null) {
-        const res = await this.getUrlEncoded(proxy, '/axis-cgi/disks/mount.cgi', {
+    async _doSDCardMountAction(action, options) {
+        const res = await this.postUrlEncoded('/axis-cgi/disks/mount.cgi', {
             action: action,
             diskid: 'SD_DISK',
-        });
+        }, undefined, options);
         const textXml = await res.text();
         const parser = new XMLParser({
             ignoreAttributes: false,
@@ -122,11 +130,11 @@ export class VapixAPI {
         }
         return Number(job.jobid);
     }
-    async fetchSDCardJobProgress(jobId, proxy = null) {
-        const res = await this.getUrlEncoded(proxy, '/disks/job.cgi', {
+    async fetchSDCardJobProgress(jobId, options) {
+        const res = await this.postUrlEncoded('/disks/job.cgi', {
             jobid: String(jobId),
             diskid: 'SD_DISK',
-        });
+        }, undefined, options);
         const textXml = await res.text();
         const parser = new XMLParser({
             ignoreAttributes: false,
@@ -139,15 +147,15 @@ export class VapixAPI {
         }
         return Number(job.progress);
     }
-    downloadCameraReport(proxy = null) {
-        return this.getUrlEncoded(proxy, '/axis-cgi/serverreport.cgi', { mode: 'text' });
+    downloadCameraReport(options) {
+        return this.postUrlEncoded('/axis-cgi/serverreport.cgi', { mode: 'text' }, undefined, options);
     }
-    getSystemLog(proxy = null) {
-        return this.getUrlEncoded(proxy, '/axis-cgi/admin/systemlog.cgi');
+    getSystemLog(options) {
+        return this.postUrlEncoded('/axis-cgi/admin/systemlog.cgi', undefined, undefined, options);
     }
-    async getMaxFps(channel, proxy = null) {
+    async getMaxFps(channel, options) {
         const data = { apiVersion: '1.0', method: 'getCaptureModes' };
-        const res = await this.postJson(proxy, '/axis-cgi/capturemode.cgi', data);
+        const res = await this.postJson('/axis-cgi/capturemode.cgi', data, undefined, options);
         const response = maxFpsResponseSchema.parse(await res.json());
         const channels = response.data;
         if (channels === undefined) {
@@ -167,9 +175,10 @@ export class VapixAPI {
         }
         return captureMode.maxFPS;
     }
-    async getTimezone(proxy = null) {
+    async getTimezone(options) {
         try {
-            const resV2 = await this.client.get(proxy, '/config/rest/time/v2/timeZone');
+            const agent = this.getAgent(options?.proxyParams);
+            const resV2 = await agent.get({ path: '/config/rest/time/v2/timeZone', timeout: options?.timeout });
             if (!resV2.ok) {
                 throw new Error(await responseStringify(resV2));
             }
@@ -184,20 +193,20 @@ export class VapixAPI {
             console.warn('Failed to fetch time zone data from time API v2:', error instanceof Error ? error.message : JSON.stringify(error));
             console.warn('Falling back to deprecated time API v1');
         }
-        const data = await this.getDateTimeInfo(proxy);
+        const data = await this.getDateTimeInfo(options);
         if (data.data.timeZone === undefined) {
             throw new Error('Time zone not setup on the device');
         }
         return data.data.timeZone;
     }
-    async getDateTimeInfo(proxy = null) {
+    async getDateTimeInfo(options) {
         const data = { apiVersion: '1.0', method: 'getDateTimeInfo' };
-        const res = await this.postJson(proxy, '/axis-cgi/time.cgi', data);
+        const res = await this.postJson('/axis-cgi/time.cgi', data, undefined, options);
         return dateTimeinfoSchema.parse(await res.json());
     }
-    async getDevicesSettings(proxy = null) {
+    async getDevicesSettings(options) {
         const data = { apiVersion: '1.0', method: 'getDevicesSettings' };
-        const res = await this.postJson(proxy, '/axis-cgi/audiodevicecontrol.cgi', data);
+        const res = await this.postJson('/axis-cgi/audiodevicecontrol.cgi', data, undefined, options);
         const result = audioDeviceRequestSchema.parse(await res.json());
         return result.data.devices.map((device) => ({
             ...device,
@@ -205,44 +214,44 @@ export class VapixAPI {
             outputs: (device.outputs || []).sort((a, b) => a.id.localeCompare(b.id)),
         }));
     }
-    async fetchRemoteDeviceInfo(payload, proxy = null) {
-        const res = await this.postJson(proxy, '/axis-cgi/basicdeviceinfo.cgi', payload);
+    async fetchRemoteDeviceInfo(payload, options) {
+        const res = await this.postJson('/axis-cgi/basicdeviceinfo.cgi', payload, undefined, options);
         const json = await res.json();
         if (isNullish(json.data)) {
             throw new NoDeviceInfoError();
         }
         return json.data;
     }
-    async getHeaders(proxy = null) {
+    async getHeaders(options) {
         const data = { apiVersion: '1.0', method: 'list' };
-        const res = await this.postJson(proxy, '/axis-cgi/customhttpheader.cgi', data);
+        const res = await this.postJson('/axis-cgi/customhttpheader.cgi', data, undefined, options);
         return z.object({ data: z.record(z.string()) }).parse(await res.json()).data;
     }
-    async setHeaders(headers, proxy = null) {
+    async setHeaders(headers, options) {
         const data = { apiVersion: '1.0', method: 'set', params: headers };
-        return this.postJson(proxy, '/axis-cgi/customhttpheader.cgi', data);
+        return this.postJson('/axis-cgi/customhttpheader.cgi', data, undefined, options);
     }
-    async getParameter(paramNames, proxy = null) {
-        const response = await this.getUrlEncoded(proxy, '/axis-cgi/param.cgi', {
+    async getParameter(paramNames, options) {
+        const response = await this.postUrlEncoded('/axis-cgi/param.cgi', {
             action: 'list',
             group: arrayToUrl(paramNames),
-        });
-        return parseParameters(await response.text());
+        }, undefined, options);
+        return VapixAPI.parseParameters(await response.text());
     }
-    async setParameter(params, proxy = null) {
-        const res = await this.getUrlEncoded(proxy, '/axis-cgi/param.cgi', {
+    async setParameter(params, options) {
+        const res = await this.postUrlEncoded('/axis-cgi/param.cgi', {
             ...params,
             action: 'update',
-        });
+        }, undefined, options);
         const responseText = await res.text();
         if (responseText.startsWith('# Error')) {
             throw new Error(responseText);
         }
         return true;
     }
-    async getGuardTourList(proxy = null) {
+    async getGuardTourList(options) {
         const gTourList = new Array();
-        const response = await this.getParameter('GuardTour', proxy);
+        const response = await this.getParameter('GuardTour', options);
         for (let i = 0; i < 20; i++) {
             const gTourBaseName = 'root.GuardTour.G' + i;
             if (gTourBaseName + '.CamNbr' in response) {
@@ -276,16 +285,16 @@ export class VapixAPI {
         }
         return gTourList;
     }
-    setGuardTourEnabled(guardTourID, enable, proxy = null) {
-        const options = {};
-        options[guardTourID + '.Running'] = enable ? 'yes' : 'no';
-        return this.setParameter(options, proxy);
+    setGuardTourEnabled(guardTourID, enable, options) {
+        const params = {};
+        params[guardTourID + '.Running'] = enable ? 'yes' : 'no';
+        return this.setParameter(params, options);
     }
-    async getPTZPresetList(channel, proxy = null) {
-        const res = await this.getUrlEncoded(proxy, '/axis-cgi/com/ptz.cgi', {
+    async getPTZPresetList(channel, options) {
+        const res = await this.postUrlEncoded('/axis-cgi/com/ptz.cgi', {
             query: 'presetposcam',
             camera: channel.toString(),
-        });
+        }, undefined, options);
         const text = await res.text();
         const lines = text.split(/[\r\n]/);
         const positions = [];
@@ -300,29 +309,29 @@ export class VapixAPI {
         }
         return positions;
     }
-    async listPTZ(camera, proxy = null) {
+    async listPTZ(camera, options) {
         const url = `/axis-cgi/com/ptz.cgi`;
-        const response = await this.getUrlEncoded(proxy, url, {
+        const response = await this.postUrlEncoded(url, {
             camera,
             query: 'presetposcamdata',
             format: 'json',
-        });
+        }, undefined, options);
         const text = await response.text();
         if (text === '') {
             throw new PtzNotSupportedError();
         }
-        return parseCameraPtzResponse(text)[camera] ?? [];
+        return VapixAPI.parseCameraPtzResponse(text)[camera] ?? [];
     }
-    async listPtzVideoSourceOverview(proxy = null) {
-        const response = await this.getUrlEncoded(proxy, '/axis-cgi/com/ptz.cgi', {
+    async listPtzVideoSourceOverview(options) {
+        const response = await this.postUrlEncoded('/axis-cgi/com/ptz.cgi', {
             query: 'presetposall',
             format: 'json',
-        });
+        }, undefined, options);
         const text = await response.text();
         if (text === '') {
             throw new PtzNotSupportedError();
         }
-        const data = parseCameraPtzResponse(text);
+        const data = VapixAPI.parseCameraPtzResponse(text);
         const res = {};
         Object.keys(data)
             .map(Number)
@@ -333,63 +342,52 @@ export class VapixAPI {
         });
         return res;
     }
-    goToPreset(channel, presetName, proxy = null) {
-        return this.getUrlEncoded(proxy, '/axis-cgi/com/ptz.cgi', {
+    goToPreset(channel, presetName, options) {
+        return this.postUrlEncoded('/axis-cgi/com/ptz.cgi', {
             camera: channel.toString(),
             gotoserverpresetname: presetName,
-        });
+        }, undefined, options);
     }
-    async getPtzPosition(camera, proxy = null) {
-        const res = await this.getUrlEncoded(proxy, '/axis-cgi/com/ptz.cgi', {
+    async getPtzPosition(camera, options) {
+        const res = await this.postUrlEncoded('/axis-cgi/com/ptz.cgi', {
             query: 'position',
             camera: camera.toString(),
-        });
-        const params = parseParameters(await res.text());
+        }, undefined, options);
+        const params = VapixAPI.parseParameters(await res.text());
         return {
             pan: Number(params.pan),
             tilt: Number(params.tilt),
             zoom: Number(params.zoom),
         };
     }
-    async getPorts(proxy = null) {
-        const body = JSON.stringify({
+    async getPorts(options) {
+        const res = await this.postJson('/axis-cgi/io/portmanagement.cgi', {
             apiVersion: '1.0',
             context: '',
             method: 'getPorts',
-        });
-        const res = await this.client.post(proxy, '/axis-cgi/io/portmanagement.cgi', body, {}, { 'Content-Type': 'application/json' });
-        if (!res.ok) {
-            throw new Error(await responseStringify(res));
-        }
+        }, undefined, options);
         const portResponseParsed = await getPortsResponseSchema.parse(res.json());
         return portResponseParsed.data.items;
     }
-    async setPorts(ports, proxy = null) {
-        const body = JSON.stringify({
+    async setPorts(ports, options) {
+        await this.postJson('/axis-cgi/io/portmanagement.cgi', {
             apiVersion: '1.0',
             context: '',
             method: 'setPorts',
             params: { ports },
-        });
-        const res = await this.client.post(proxy, '/axis-cgi/io/portmanagement.cgi', body, {}, { 'Content-Type': 'application/json' });
-        if (!res.ok) {
-            throw new Error(await responseStringify(res));
-        }
+        }, undefined, options);
     }
-    async setPortStateSequence(port, sequence, proxy = null) {
-        const body = JSON.stringify({
+    async setPortStateSequence(port, sequence, options) {
+        await this.postJson('/axis-cgi/io/portmanagement.cgi', {
             apiVersion: '1.0',
             context: '',
             method: 'setStateSequence',
             params: { port, sequence },
-        });
-        const res = await this.client.post(proxy, '/axis-cgi/io/portmanagement.cgi', body, {}, { 'Content-Type': 'application/json' });
-        if (!res.ok) {
-            throw new Error(await responseStringify(res));
-        }
+        }, undefined, options);
     }
-    async getApplicationList(proxy = null) {
-        const res = await this.client.get(proxy, '/axis-cgi/applications/list.cgi');
+    async getApplicationList(options) {
+        const agent = this.getAgent(options?.proxyParams);
+        const res = await agent.get({ path: '/axis-cgi/applications/list.cgi', timeout: options?.timeout });
         const xml = await res.text();
         const parser = new XMLParser({
             ignoreAttributes: false,
@@ -408,41 +406,62 @@ export class VapixAPI {
             };
         });
     }
-    async startApplication(applicationID, proxy = null) {
-        const res = await this.client.get(proxy, '/axis-cgi/applications/control.cgi', {
-            package: applicationID.toLowerCase(),
-            action: 'start',
+    async startApplication(applicationID, options) {
+        const agent = this.getAgent(options?.proxyParams);
+        const res = await agent.get({
+            path: '/axis-cgi/applications/control.cgi',
+            parameters: {
+                package: applicationID.toLowerCase(),
+                action: 'start',
+            },
+            timeout: options?.timeout,
         });
         const text = (await res.text()).trim().toLowerCase();
         if (text !== 'ok' && !(text.startsWith('error:') && text.substring(7) === '6')) {
             throw new ApplicationAPIError('START', await responseStringify(res));
         }
     }
-    async restartApplication(applicationID, proxy = null) {
-        const res = await this.client.get(proxy, '/axis-cgi/applications/control.cgi', {
-            package: applicationID.toLowerCase(),
-            action: 'restart',
+    async restartApplication(applicationID, options) {
+        const agent = this.getAgent(options?.proxyParams);
+        const res = await agent.get({
+            path: '/axis-cgi/applications/control.cgi',
+            parameters: {
+                package: applicationID.toLowerCase(),
+                action: 'restart',
+            },
+            timeout: options?.timeout,
         });
         const text = (await res.text()).trim().toLowerCase();
         if (text !== 'ok') {
             throw new ApplicationAPIError('RESTART', await responseStringify(res));
         }
     }
-    async stopApplication(applicationID, proxy = null) {
-        const res = await this.client.get(proxy, '/axis-cgi/applications/control.cgi', {
-            package: applicationID.toLowerCase(),
-            action: 'stop',
+    async stopApplication(applicationID, options) {
+        const agent = this.getAgent(options?.proxyParams);
+        const res = await agent.get({
+            path: '/axis-cgi/applications/control.cgi',
+            parameters: {
+                package: applicationID.toLowerCase(),
+                action: 'stop',
+            },
+            timeout: options?.timeout,
         });
         const text = (await res.text()).trim().toLowerCase();
         if (text !== 'ok' && !(text.startsWith('error:') && text.substring(7) === '6')) {
             throw new ApplicationAPIError('STOP', await responseStringify(res));
         }
     }
-    async installApplication(data, fileName) {
+    async installApplication(data, fileName, options) {
         const formData = new FormData();
         formData.append('packfil', data, fileName);
-        const res = await this.client.post(null, '/axis-cgi/applications/upload.cgi', formData, {}, {
-            contentType: 'application/octet-stream',
+        const agent = this.getAgent(options?.proxyParams);
+        const res = await agent.post({
+            path: '/axis-cgi/applications/upload.cgi',
+            data: formData,
+            headers: {
+                contentType: 'application/octet-stream',
+            },
+            timeout: options?.timeout ?? 120000,
         });
         if (!res.ok) {
             throw new Error(await responseStringify(res));
@@ -452,70 +471,73 @@ export class VapixAPI {
             throw new Error('installing error: ' + text);
         }
     }
-}
-const parseParameters = (response) => {
-    const params = {};
-    const lines = response.split(/[\r\n]/);
-    for (const line of lines) {
-        if (line.length === 0 || line.substring(0, 7) === '# Error') {
-            continue;
-        }
-        const delimiterPos = line.indexOf('=');
-        if (delimiterPos !== -1) {
-            const paramName = line.substring(0, delimiterPos).replace('root.', '');
-            const paramValue = line.substring(delimiterPos + 1);
-            params[paramName] = paramValue;
-        }
-    }
-    return params;
-};
-const parseCameraPtzResponse = (response) => {
-    const json = JSON.parse(response);
-    const parsed = {};
-    Object.keys(json).forEach((key) => {
-        if (!key.startsWith('Camera ')) {
-            return;
-        }
-        const camera = Number(key.replace('Camera ', ''));
-        if (json[key].presets !== undefined) {
-            parsed[camera] = parsePtz(json[key].presets);
-        }
-    });
-    return parsed;
-};
-const parsePtz = (parsed) => {
-    const res = [];
-    parsed.forEach((value) => {
-        const delimiterPos = value.indexOf('=');
-        if (delimiterPos === -1) {
-            return;
-        }
-        if (!value.startsWith('presetposno')) {
-            return;
-        }
-        const id = Number(value.substring(11, delimiterPos));
-        if (Number.isNaN(id)) {
-            return;
+    static parseParameters = (response) => {
+        const params = {};
+        const lines = response.split(/[\r\n]/);
+        for (const line of lines) {
+            if (line.length === 0 || line.substring(0, 7) === '# Error') {
+                continue;
+            }
+            const delimiterPos = line.indexOf('=');
+            if (delimiterPos !== -1) {
+                const paramName = line.substring(0, delimiterPos).replace('root.', '');
+                const paramValue = line.substring(delimiterPos + 1);
+                params[paramName] = paramValue;
+            }
         }
-        const data = value.substring(delimiterPos + 1).split(':');
-        const getValue = (valueName) => {
-            for (const d of data) {
-                const p = d.split('=');
-                if (p[0] === valueName) {
-                    return Number(p[1]);
-                }
+        return params;
+    };
+    static parseCameraPtzResponse = (response) => {
+        const json = JSON.parse(response);
+        const parsed = {};
+        Object.keys(json).forEach((key) => {
+            if (!key.startsWith('Camera ')) {
+                return;
+            }
+            const camera = Number(key.replace('Camera ', ''));
+            if (json[key].presets !== undefined) {
+                parsed[camera] = VapixAPI.parsePtz(json[key].presets);
             }
-            return 0;
-        };
-        res.push({
-            id,
-            name: data[0] ?? 'Preset ' + id,
-            data: {
-                pan: getValue('pan'),
-                tilt: getValue('tilt'),
-                zoom: getValue('zoom'),
-            },
         });
-    });
-    return res;
-};
+        return parsed;
+    };
+    static parsePtz = (parsed) => {
+        const res = [];
+        parsed.forEach((value) => {
+            const delimiterPos = value.indexOf('=');
+            if (delimiterPos === -1) {
+                return;
+            }
+            if (!value.startsWith('presetposno')) {
+                return;
+            }
+            const id = Number(value.substring(11, delimiterPos));
+            if (Number.isNaN(id)) {
+                return;
+            }
+            const data = value.substring(delimiterPos + 1).split(':');
+            const getValue = (valueName) => {
+                for (const d of data) {
+                    const p = d.split('=');
+                    if (p[0] === valueName) {
+                        return Number(p[1]);
+                    }
+                }
+                return 0;
+            };
+            res.push({
+                id,
+                name: data[0] ?? 'Preset ' + id,
+                data: {
+                    pan: getValue('pan'),
+                    tilt: getValue('tilt'),
+                    zoom: getValue('zoom'),
+                },
+            });
+        });
+        return res;
+    };
+    getAgent(proxyParams) {
+        return proxyParams ? new ProxyClient(this.client, proxyParams) : this.client;
+    }
+}

package/esm/events/AxisCameraStationEvents.d.ts

@@ -1,10 +1,10 @@
-import { IClient, HttpOptions } from '../internal/types';
-import { Response } from 'undici';
-export type AcsEventsOptions = HttpOptions;
+import { HttpOptions } from '../internal/types';
+import { THttpRequestOptions } from '../types/common';
 export declare class AxisCameraStationEvents {
     private sourceKey;
     private client;
-    constructor(sourceKey: string, opt?: AcsEventsOptions | IClient<Response>);
-    sendEvent(data: Record<string, string>, eventType: string): Promise<void>;
+    constructor(clientOptions: HttpOptions, sourceKey: string);
+    sendEvent(data: Record<string, string>, eventType: string, options?: THttpRequestOptions): Promise<void>;
     private getDate;
+    private getAgent;
 }