camstreamerlib 4.0.0-beta.33 → 4.0.0-beta.35

package/{cjs → types}/CamOverlayAPI.d.ts

@@ -1,10 +1,8 @@
-/// <reference types="node" />
-/// <reference types="node" />
 import { IClient, TBlobResponse, TResponse } from './internal/types';
 import { THttpRequestOptions, TProxyParams, TNetworkCamera } from './types/common';
 import { ProxyClient } from './internal/ProxyClient';
 import { ImageType, TCoordinates, TField, TFile, TFileList, TFileType, TStorage, TStorageDataList, TWidget } from './types/CamOverlayAPI';
-export declare class CamOverlayAPI<Client extends IClient<TResponse> = IClient<TResponse>> {
+export declare class CamOverlayAPI<Client extends IClient<TResponse, any>> {
     private client;
     constructor(client: Client);
     static getBasePath: () => string;
@@ -16,7 +14,7 @@ export declare class CamOverlayAPI<Client extends IClient<TResponse> = IClient<T
     wsAuthorization(options?: THttpRequestOptions): Promise<string>;
     getMjpegStreamImage(mjpegUrl: string, options?: THttpRequestOptions): Promise<TBlobResponse<Client>>;
     listFiles(fileType: TFileType, options?: THttpRequestOptions): Promise<TFileList>;
-    uploadFile(fileType: TFileType, formData: FormData, storage: TStorage, options?: THttpRequestOptions): Promise<void>;
+    uploadFile(fileType: TFileType, formData: Parameters<Client['post']>[0]['data'], storage: TStorage, options?: THttpRequestOptions): Promise<void>;
     removeFile(fileType: TFileType, fileParams: TFile, options?: THttpRequestOptions): Promise<void>;
     getFileStorage(fileType: TFileType, options?: THttpRequestOptions): Promise<TStorageDataList>;
     getFilePreviewFromCamera(path: string, options?: THttpRequestOptions): Promise<TBlobResponse<Client>>;
@@ -30,7 +28,7 @@ export declare class CamOverlayAPI<Client extends IClient<TResponse> = IClient<T
     updateCGText(serviceId: number, fields: TField[], options?: THttpRequestOptions): Promise<void>;
     updateCGImagePos(serviceId: number, coordinates?: TCoordinates, x?: number, y?: number, options?: THttpRequestOptions): Promise<void>;
     updateCGImage(serviceId: number, path: string, coordinates?: TCoordinates, x?: number, y?: number, options?: THttpRequestOptions): Promise<void>;
-    updateCGImageFromData(serviceId: number, imageType: ImageType, imageData: Buffer, coordinates?: TCoordinates, x?: number, y?: number, options?: THttpRequestOptions): Promise<void>;
+    updateCGImageFromData(serviceId: number, imageType: ImageType, imageData: Parameters<Client['post']>[0]['data'], coordinates?: TCoordinates, x?: number, y?: number, options?: THttpRequestOptions): Promise<void>;
     private promiseCGUpdate;
     private _get;
     private _post;

package/{esm → types}/CamScripterAPI.d.ts

@@ -2,7 +2,7 @@ import { ProxyClient } from './internal/ProxyClient';
 import { IClient, TResponse } from './internal/types';
 import { TNodeState, TPackageInfoList, TStorage, TStorageType } from './types/CamScripterAPI';
 import { THttpRequestOptions, TNetworkCamera, TProxyParams } from './types/common';
-export declare class CamScripterAPI<Client extends IClient<TResponse> = IClient<TResponse>> {
+export declare class CamScripterAPI<Client extends IClient<TResponse, any>> {
     client: Client;
     constructor(client: Client);
     static getProxyUrlPath: () => string;
@@ -11,7 +11,7 @@ export declare class CamScripterAPI<Client extends IClient<TResponse> = IClient<
     getNetworkCameraList(options?: THttpRequestOptions): Promise<TNetworkCamera[]>;
     getStorageInfo(options?: THttpRequestOptions): Promise<TStorage>;
     getPackageList(options?: THttpRequestOptions): Promise<TPackageInfoList>;
-    installPackages(formData: FormData, storage: TStorageType, options?: THttpRequestOptions): Promise<{
+    installPackages(formData: Parameters<Client['post']>[0]['data'], storage: TStorageType, options?: THttpRequestOptions): Promise<{
         status: number;
         message: string;
     }>;
@@ -19,11 +19,11 @@ export declare class CamScripterAPI<Client extends IClient<TResponse> = IClient<
         status: number;
         message: string;
     }>;
-    importSettings(packageId: string, formData: FormData, options?: THttpRequestOptions): Promise<{
+    importSettings(packageId: string, formData: Parameters<Client['post']>[0]['data'], options?: THttpRequestOptions): Promise<{
         status: number;
         message: string;
     }>;
-    exportSettings(packageId: string, formData: FormData, options?: THttpRequestOptions): Promise<{
+    exportSettings(packageId: string, formData: Parameters<Client['post']>[0]['data'], options?: THttpRequestOptions): Promise<{
         status: number;
         message: string;
     }>;

package/types/CamStreamerAPI.d.ts

@@ -0,0 +1,48 @@
+import { ProxyClient } from './internal/ProxyClient';
+import { IClient, TResponse } from './internal/types';
+import { TCameraStream, TStream } from './types/CamStreamerAPI';
+import { THttpRequestOptions, TProxyParams } from './types/common';
+export declare class CamStreamerAPI<Client extends IClient<TResponse, any>> {
+    client: Client;
+    constructor(client: Client);
+    getClient(proxyParams?: TProxyParams): Client | ProxyClient<Client>;
+    getStreamList(options?: THttpRequestOptions): Promise<Record<number, {
+        enabled: 0 | 1;
+        schedule: string;
+        active: 0 | 1;
+        audioSource: string;
+        avSyncMsec: number;
+        internalVapixParameters: string;
+        userVapixParameters: string;
+        outputParameters: string;
+        outputType: "video" | "images" | "none";
+        mediaServerUrl: string;
+        inputType: "RTSP_URL" | "CSw" | "CRS";
+        inputUrl: string;
+        forceStereo: 0 | 1;
+        streamDelay: number | null;
+        statusLed: number;
+        statusPort: string;
+        callApi: number;
+        trigger: string;
+        prepareAhead: number;
+        startTime: number | null;
+        stopTime: number | null;
+    }>>;
+    getStream(streamId: number, options?: THttpRequestOptions): Promise<TStream>;
+    getStreamParameter(streamId: number, paramName: string, options?: THttpRequestOptions): Promise<string>;
+    setStream(streamId: number, params: Partial<TStream>, options?: THttpRequestOptions): Promise<{
+        message: string;
+        status: number;
+    }>;
+    setStreamParameter(streamId: number, paramName: string, value: string, options?: THttpRequestOptions): Promise<{
+        message: string;
+        status: number;
+    }>;
+    isStreaming(streamId: number, options?: THttpRequestOptions): Promise<boolean>;
+    deleteStream(streamId: number, options?: THttpRequestOptions): Promise<boolean>;
+    getWsAuthorization(options?: THttpRequestOptions): Promise<string>;
+    getUtcTime(options?: THttpRequestOptions): Promise<number>;
+    private get;
+}
+export declare const parseCameraStreamResponse: (cameraStreamData: TCameraStream) => TStream;

package/{esm → types}/CamSwitcherAPI.d.ts

@@ -2,7 +2,7 @@ import { IClient, TResponse } from './internal/types';
 import { TAudioPushInfo, TOutputInfo, TStorageInfo, TStreamSaveList, TClipList, TStreamSaveLoadList, TClipSaveLoadList, TPlaylistSaveLoadList, TTrackerSaveList, TrackerSaveLoadList, TClipSaveList, TPlaylistSaveList, TCameraOptions, TGlobalAudioSettings, TSecondaryAudioSettings } from './types/CamSwitcherAPI';
 import { TAudioChannel, THttpRequestOptions, TNetworkCamera, TProxyParams, TStorageType } from './types/common';
 import { ProxyClient } from './internal/ProxyClient';
-export declare class CamSwitcherAPI<Client extends IClient<TResponse> = IClient<TResponse>> {
+export declare class CamSwitcherAPI<Client extends IClient<TResponse, any>> {
     client: Client;
     private CustomFormData;
     private vapixAgent;
@@ -35,14 +35,14 @@ export declare class CamSwitcherAPI<Client extends IClient<TResponse> = IClient<
     playlistQueueClear(options?: THttpRequestOptions): Promise<void>;
     playlistQueueList(options?: THttpRequestOptions): Promise<string[]>;
     playlistQueuePlayNext(options?: THttpRequestOptions): Promise<void>;
-    addNewClip(file: any, clipType: 'video' | 'audio', storage: TStorageType, id: string, fileName?: string, options?: THttpRequestOptions): Promise<void>;
-    removeClip(id: string, storage: TStorageType, options?: THttpRequestOptions): Promise<any>;
+    addNewClip(file: any, clipType: 'video' | 'audio', storage: TStorageType, clipId: string, fileName?: string, options?: THttpRequestOptions): Promise<void>;
+    removeClip(clipId: string, storage: TStorageType, options?: THttpRequestOptions): Promise<any>;
     getClipList(options?: THttpRequestOptions): Promise<TClipList>;
-    setCamSwitchOptions(data: TCameraOptions, cameraFWVersion: string, options?: THttpRequestOptions): Promise<boolean>;
-    setGlobalAudioSettings(settings: TGlobalAudioSettings, options?: THttpRequestOptions): Promise<boolean>;
-    setSecondaryAudioSettings(settings: TSecondaryAudioSettings, options?: THttpRequestOptions): Promise<boolean>;
-    setDefaultPlaylist(id: string, options?: THttpRequestOptions): Promise<boolean>;
-    setPermanentRtspUrlToken(token: string, options?: THttpRequestOptions): Promise<boolean>;
+    setCamSwitchOptions(data: TCameraOptions, cameraFWVersion: string, options?: THttpRequestOptions): Promise<void>;
+    setGlobalAudioSettings(settings: TGlobalAudioSettings, options?: THttpRequestOptions): Promise<void>;
+    setSecondaryAudioSettings(settings: TSecondaryAudioSettings, options?: THttpRequestOptions): Promise<void>;
+    setDefaultPlaylist(playlistId: string, options?: THttpRequestOptions): Promise<void>;
+    setPermanentRtspUrlToken(token: string, options?: THttpRequestOptions): Promise<void>;
     getCamSwitchOptions(options?: THttpRequestOptions): Promise<Partial<TCameraOptions>>;
     getGlobalAudioSettings(options?: THttpRequestOptions): Promise<TGlobalAudioSettings>;
     getSecondaryAudioSettings(options?: THttpRequestOptions): Promise<TSecondaryAudioSettings>;

package/types/CamSwitcherEvents.d.ts

@@ -0,0 +1,8 @@
+import { IWebsocket } from './internal/types';
+import { WsEvents } from './internal/WsEvents';
+import { TCamSwitcherEvent } from './types/CamSwitcherEvents';
+export declare class CamSwitcherEvents<Event extends {
+    data: string;
+}> extends WsEvents<TCamSwitcherEvent, Event> {
+    constructor(ws: IWebsocket<Event>);
+}

package/types/PlaneTrackerAPI.d.ts

@@ -0,0 +1,43 @@
+import { IClient, TBlobResponse, TParameters, TResponse } from './internal/types';
+import { ICAO, TApiUser, TExportDataType, TImportDataType } from './types/PlaneTrackerAPI';
+import { THttpRequestOptions, TProxyParams } from './types/common';
+import { ProxyClient } from './internal/ProxyClient';
+export declare class PlaneTrackerAPI<Client extends IClient<TResponse, any>> {
+    private client;
+    private apiUser;
+    constructor(client: Client, apiUser: TApiUser);
+    static getProxyUrlPath: () => string;
+    getClient(proxyParams?: TProxyParams): Client | ProxyClient<Client>;
+    checkCameraTime(options?: THttpRequestOptions): Promise<boolean>;
+    resetPtzCalibration(options?: THttpRequestOptions): Promise<TResponse>;
+    resetFocusCalibration(options?: THttpRequestOptions): Promise<TResponse>;
+    serverRunCheck(options?: THttpRequestOptions): Promise<TResponse>;
+    getLiveViewAlias(rtspUrl: string, options?: THttpRequestOptions): Promise<TResponse>;
+    fetchCameraSettings(options?: THttpRequestOptions): Promise<any>;
+    setCameraSettings(settingsJsonString: string, options?: THttpRequestOptions): Promise<TResponse>;
+    fetchServerSettings(options?: THttpRequestOptions): Promise<any>;
+    exportAppSettings(dataType: TExportDataType, options?: THttpRequestOptions): Promise<TBlobResponse<Client>>;
+    importAppSettings(dataType: TImportDataType, formData: Parameters<Client['post']>[0]['data'], options?: THttpRequestOptions): Promise<TResponse>;
+    fetchFlightInfo(icao: ICAO, options?: THttpRequestOptions): Promise<any>;
+    getTrackingMode(options?: THttpRequestOptions): Promise<any>;
+    setTrackingMode(modeJsonString: string, options?: THttpRequestOptions): Promise<TResponse>;
+    startTrackingPlane(icao: ICAO, options?: THttpRequestOptions): Promise<TResponse>;
+    stopTrackingPlane(options?: THttpRequestOptions): Promise<TResponse>;
+    getPriorityList(options?: THttpRequestOptions): Promise<any>;
+    setPriorityList(priorityListJsonString: string, options?: THttpRequestOptions): Promise<TResponse>;
+    getWhiteList(options?: THttpRequestOptions): Promise<any>;
+    setWhiteList(whiteListJsonString: string, options?: THttpRequestOptions): Promise<TResponse>;
+    getBlackList(options?: THttpRequestOptions): Promise<any>;
+    setBlackList(blackListJsonString: string, options?: THttpRequestOptions): Promise<TResponse>;
+    fetchMapInfo(options?: THttpRequestOptions): Promise<any>;
+    getZones(options?: THttpRequestOptions): Promise<any>;
+    setZones(zonesJsonString: string, options?: THttpRequestOptions): Promise<TResponse>;
+    goToCoordinates(lat: number, lon: number, alt?: number, options?: THttpRequestOptions): Promise<TResponse>;
+    checkGenetecConnection(params: TParameters, options?: THttpRequestOptions): Promise<TResponse>;
+    getGenetecCameraList(params: TParameters, options?: THttpRequestOptions): Promise<any>;
+    private _getJson;
+    private _getBlob;
+    private parseBlobResponse;
+    private _postJsonEncoded;
+    private _postUrlEncoded;
+}

package/{cjs → types}/VapixAPI.d.ts

@@ -2,13 +2,17 @@ import { IClient, TParameters, TResponse } from './internal/types';
 import { TAudioSampleRates, TSDCardInfo, TPtzOverview, TCameraPTZItem, TCameraPTZItemData, TAudioDevice, TPortSetSchema, TPortSequenceStateSchema } from './types/VapixAPI';
 import { ProxyClient } from './internal/ProxyClient';
 import { TCameraImageConfig, THttpRequestOptions, TProxyParams } from './types/common';
-export declare class VapixAPI<Client extends IClient<TResponse> = IClient<TResponse>> {
-    private client;
-    constructor(client: Client);
+export declare class VapixAPI<Client extends IClient<TResponse, any>> {
+    client: Client;
+    private CustomFormData;
+    constructor(client: Client, CustomFormData?: {
+        new (form?: HTMLFormElement | undefined, submitter?: HTMLElement | null | undefined): FormData;
+        prototype: FormData;
+    });
     getClient(proxyParams?: TProxyParams): Client | ProxyClient<Client>;
     postUrlEncoded(path: string, parameters?: TParameters, headers?: Record<string, string>, options?: THttpRequestOptions): Promise<TResponse>;
     postJson(path: string, jsonData: Record<string, any>, headers?: Record<string, string>, options?: THttpRequestOptions): Promise<TResponse>;
-    getCameraImage(parameters: TCameraImageConfig, options?: THttpRequestOptions): Promise<TResponse>;
+    getCameraImage(parameters: TCameraImageConfig, options?: THttpRequestOptions): Promise<ReturnType<Client["get"]>>;
     getEventDeclarations(options?: THttpRequestOptions): Promise<string>;
     getSupportedAudioSampleRate(options?: THttpRequestOptions): Promise<TAudioSampleRates[]>;
     performAutofocus(options?: THttpRequestOptions): Promise<void>;
@@ -35,7 +39,7 @@ export declare class VapixAPI<Client extends IClient<TResponse> = IClient<TRespo
     getHeaders(options?: THttpRequestOptions): Promise<Record<string, string>>;
     setHeaders(headers: Record<string, string>, options?: THttpRequestOptions): Promise<TResponse>;
     getParameter(paramNames: string | string[], options?: THttpRequestOptions): Promise<Record<string, string>>;
-    setParameter(params: Record<string, string | number | boolean>, options?: THttpRequestOptions): Promise<boolean>;
+    setParameter(params: Record<string, string | number | boolean>, options?: THttpRequestOptions): Promise<void>;
     getGuardTourList(options?: THttpRequestOptions): Promise<{
         name: string;
         id: string;
@@ -51,7 +55,7 @@ export declare class VapixAPI<Client extends IClient<TResponse> = IClient<TRespo
         randomEnabled?: unknown;
         timeBetweenSequences?: unknown;
     }[]>;
-    setGuardTourEnabled(guardTourID: string, enable: boolean, options?: THttpRequestOptions): Promise<boolean>;
+    setGuardTourEnabled(guardTourID: string, enable: boolean, options?: THttpRequestOptions): Promise<void>;
     getPTZPresetList(channel: number, options?: THttpRequestOptions): Promise<string[]>;
     listPTZ(camera: number, options?: THttpRequestOptions): Promise<TCameraPTZItem[]>;
     listPtzVideoSourceOverview(options?: THttpRequestOptions): Promise<TPtzOverview>;
@@ -73,7 +77,7 @@ export declare class VapixAPI<Client extends IClient<TResponse> = IClient<TRespo
     startApplication(applicationID: string, options?: THttpRequestOptions): Promise<void>;
     restartApplication(applicationID: string, options?: THttpRequestOptions): Promise<void>;
     stopApplication(applicationID: string, options?: THttpRequestOptions): Promise<void>;
-    installApplication(data: Blob, fileName: string, options?: THttpRequestOptions): Promise<void>;
+    installApplication(data: Parameters<typeof FormData.prototype.append>[1], fileName: string, options?: THttpRequestOptions): Promise<void>;
     private static parseParameters;
     private static parseCameraPtzResponse;
     private static parsePtz;

package/{cjs → types}/index.d.ts

@@ -2,6 +2,7 @@ export * from './internal/types';
 export * from './internal/constants';
 export * from './internal/utils';
 export * from './internal/versionCompare';
+export * from './internal/ProxyClient';
 export * from './types/common';
 export { CamSwitcherAPI } from './CamSwitcherAPI';
 export { CamSwitcherEvents } from './CamSwitcherEvents';
@@ -15,9 +16,3 @@ export * from './types/CamSwitcherAPI';
 export * from './types/VapixAPI';
 export * from './types/CamOverlayAPI';
 export * from './types/PlaneTrackerAPI';
-export { Frame } from './CamOverlayPainter/Frame';
-export { Painter } from './CamOverlayPainter/Painter';
-export { ResourceManager } from './CamOverlayPainter/ResourceManager';
-export * from './types/CamOverlayPainter';
-export { CamOverlayDrawingAPI } from './CamOverlayDrawingAPI';
-export * from './types/CamOverlayDrawingAPI';

package/{esm → types}/internal/ProxyClient.d.ts

@@ -1,10 +1,10 @@
-import { IClient, TGetParams, TPostParams, TResponse } from './types';
+import { IClient, TGetParams, TResponse } from './types';
 import { TProxyParams } from '../types/common';
-export declare class ProxyClient<Client extends IClient<TResponse> = IClient<TResponse>> {
+export declare class ProxyClient<Client extends IClient<TResponse, any>> {
     private client;
     private proxyParams;
     constructor(client: Client, proxyParams: TProxyParams);
-    get: (params: TGetParams) => Promise<TResponse>;
-    post: (params: TPostParams) => Promise<TResponse>;
+    get(params: TGetParams): ReturnType<Client["get"]>;
+    post(params: Parameters<Client['post']>[0]): ReturnType<Client["post"]>;
     private getReal;
 }

package/types/internal/WsEvents.d.ts

@@ -0,0 +1,41 @@
+import { IWebsocket } from './types';
+type TEventType<T extends {
+    type: string;
+}> = T extends {
+    type: infer Type;
+} ? Type : never;
+type TEvent<T extends {
+    type: string;
+}, Type extends TEventType<T>> = T extends {
+    type: Type;
+} ? T : never;
+type TZodSchema<T extends {
+    type: string;
+}> = {
+    parse: (data: string) => {
+        type: 'init';
+        data: TEvent<T, TEventType<T>>;
+    } | TEvent<T, TEventType<T>>;
+};
+type TListenerFunction<T extends {
+    type: string;
+}, Type extends TEventType<T>> = (data: TEvent<T, Type>, isInit: boolean) => void;
+export declare class WsEvents<T extends {
+    type: string;
+}, Event extends {
+    data: string;
+}> {
+    private zodSchema;
+    ws: IWebsocket<Event>;
+    private _isDestroyed;
+    private listeners;
+    constructor(zodSchema: TZodSchema<T>, ws: IWebsocket<Event>);
+    get isDestroyed(): boolean;
+    resendInitData(): void;
+    addListener<Type extends TEventType<T>>(type: Type, listener: TListenerFunction<T, Type>, id: string): void;
+    removeListener<Type extends TEventType<T>>(type: Type, id: string): void;
+    private onMessage;
+    private processMessage;
+    destroy(): void;
+}
+export {};

package/{esm → types}/internal/types.d.ts

@@ -1,6 +1,3 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import { Response as UndiciResponse } from 'undici';
 export type Options = {
     ip?: string;
     port?: number;
@@ -14,25 +11,31 @@ export type HttpOptions = Options & {
 };
 export type WsOptions = Options;
 export type TParameters = Record<string, string | number | boolean | null | undefined>;
-export type TResponse = Response | UndiciResponse;
+export type TResponse = {
+    json: () => Promise<any>;
+    text: () => Promise<string>;
+    blob: () => Promise<unknown>;
+    status: number;
+    ok: boolean;
+};
 export type TGetParams = {
     path: string;
     parameters?: TParameters;
     headers?: Record<string, string>;
     timeout?: number;
 };
-export type TPostParams = {
+export type TPostParams<Data> = {
     path: string;
-    data: string | Buffer | FormData;
+    data: string | Data;
     parameters?: TParameters;
     headers?: Record<string, string>;
     timeout?: number;
 };
-export interface IClient<TRes extends TResponse> {
+export interface IClient<TRes extends TResponse, Data> {
     get: (params: TGetParams) => Promise<TRes>;
-    post: (params: TPostParams) => Promise<TRes>;
+    post: (params: TPostParams<Data>) => Promise<TRes>;
 }
-export type TBlobResponse<Client extends IClient<TResponse>> = Awaited<ReturnType<Awaited<ReturnType<Client['get']>>['blob']>>;
+export type TBlobResponse<Client extends IClient<TResponse, any>> = Awaited<ReturnType<Awaited<ReturnType<Client['get']>>['blob']>>;
 export interface IWebsocket<Event extends {
     readonly data: string;
 }> {

package/{cjs → types}/node/DefaultClient.d.ts

@@ -1,6 +1,8 @@
+/// <reference types="node" />
+/// <reference types="node" />
 import { IClient, HttpOptions, TGetParams, TPostParams } from '../internal/types';
-import { Response as UndiciResponse } from 'undici';
-export declare class DefaultClient implements IClient<UndiciResponse> {
+import { FormData as UndiciFormData, Response as UndiciResponse } from 'undici';
+export declare class DefaultClient implements IClient<UndiciResponse, UndiciFormData | Buffer> {
     private tls;
     private ip;
     private port;
@@ -8,7 +10,7 @@ export declare class DefaultClient implements IClient<UndiciResponse> {
     private pass;
     private httpRequestSender;
     constructor(opt?: HttpOptions);
-    get: (params: TGetParams) => Promise<UndiciResponse>;
-    post: (params: TPostParams) => Promise<UndiciResponse>;
+    get(params: TGetParams): Promise<UndiciResponse>;
+    post(params: TPostParams<UndiciFormData | Buffer>): Promise<UndiciResponse>;
     private getBaseConnectionParams;
 }

package/{esm → types/node}/events/AxisCameraStationEvents.d.ts

@@ -1,7 +1,7 @@
-import { HttpOptions } from '../internal/types';
-import { THttpRequestOptions, TProxyParams } from '../types/common';
-import { ProxyClient } from '../internal/ProxyClient';
-import { DefaultClient } from '../node';
+import { HttpOptions } from '../../internal/types';
+import { ProxyClient } from '../../internal/ProxyClient';
+import { THttpRequestOptions, TProxyParams } from '../../types/common';
+import { DefaultClient } from '../DefaultClient';
 export declare class AxisCameraStationEvents {
     private sourceKey;
     private client;

package/{esm → types}/node/index.d.ts

@@ -1,5 +1,5 @@
 export * from './DefaultClient';
 export * from './WsClient';
 export * from './HttpServer';
-export * from '../events/AxisCameraStationEvents';
-export * from '../events/GenetecAgent';
+export * from './events/AxisCameraStationEvents';
+export * from './events/GenetecAgent';