onvif-nvt-ts

import Soap from '../utils/soap'; /** * All ONVIF API functions return a Promise. * * @param {Error} error The error object. * @param {string} error.message The error message. * @param {xml} error.soap Associated SOAP xml that is cause of the error. * @param {object} error.fault Fault information * @param {string} error.fault.reason Reason for the error. * @param {string} error.fault.code Code for the error. * @param {string} error.fault.detail Details of the error. * @param {data} data The returned data when there is no error. */ /** * @class * Provide core functionality for Onvif Device Management. * * {@link https://www.onvif.org/onvif/specs/core/ONVIF-Core-Specification-v220.pdf} * {@link https://www.onvif.org/ver10/device/wsdl/devicemgmt.wsdl} * {@link https://www.onvif.org/ver10/events/wsdl/event.wsdl} * * <h3>Functions</h3> * {@link Core#getWsdlUrl}, * {@link Core#getServices}, * {@link Core#getServiceCapabilities}, * {@link Core#getCapabilities}, * {@link Core#getHostname}, * {@link Core#setHostname}, * {@link Core#setHostnameFromDHCP}, * {@link Core#getDNS}, * {@link Core#setDNS}, * {@link Core#getNTP}, * {@link Core#setNTP}, * {@link Core#getDynamicDNS}, * setDynamicDNS, * {@link Core#getNetworkInterfaces}, * setNetworkInterfaces, * {@link Core#getNetworkProtocols}, * {@link Core#getNetworkDefaultGateway}, * setNetworkDefaultGateway, * {@link Core#getZeroConfiguration}, * setZeroConfiguration, * {@link Core#getIPAddressFilter}, * setIPAddressFilter, * addIPAddressFilter, * removeIPAddressFilter, * {@link Core#getDot11Capabilities}, * {@link Core#getDot11Status}, * {@link Core#scanAvailableDot11Networks}, * {@link Core#getDeviceInformation}, * {@link Core#getSystemUris}, * {@link Core#getSystemBackup}, * restoreSystem, * startSystemRestore, * {@link Core#getSystemDateAndTime}, * setSystemDateAndTime, * setSystemFactoryDefault, * upgradeSystemFirmware, * startFirmwareUpgrade, * {@link Core#getSystemLog}, * {@link Core#getSystemSupportInformation}, * {@link Core#systemReboot}, * {@link Core#getScopes}, * setScopes, * addScopes, * removeScopes, * {@link Core#getGeoLocation}, * setGeoLocation, * deleteGeoLocation, * {@link Core#getDiscoveryMode}, * setDiscoveryMode, * {@link Core#getRemoteDiscoveryMode}, * setRemoteDiscoveryMode, * {@link Core#getDPAddresses}, * setDPAddresses, * {@link Core#getAccessPolicy}, * setAccessPolicy * {@link Core#getUsers}, * createUsers, * deleteUsers, * setUser, * createDot1XConfiguration, * setDot1XConfiguration, * {@link Core#getDot1XConfiguration}, * {@link Core#getDot1XConfigurations}, * deleteDot1XConfigurations, * createCertificate, * {@link Core#getCertificates}, * {@link Core#getCACertificates}, * {@link Core#getCertificatesStatus}, * setCertificatesStatus, * getPkcs10Request, * {@link Core#getClientCertificateMode}, * setClientCertificateMode, * loadCertificates, * loadCertificateWithPrivateKey, * getCertificateInformation, * loadCACertificates, * deleteCertificates, * {@link Core#getRemoteUser}, * setRemoteUser, * {@link Core#getEndpointReference}, * {@link Core#getRelayOutputs}, * setRelayOutputSettings, * setRelayOutputState, * sendAuxiliaryCommand * * <h3>Overview</h3> * The Device Service is divided into five different categories: capabilities, network, system, I/O * and security commands. This set of commands can be used to get information about the * device capabilities and configurations or to set device configurations. An ONVIF compliant * device shall support the device management service as specified in [ONVIF DM WSDL]. A * basic set of operations are required for the device management service, other operations are * recommended or optional to support. The detailed requirements are listed under the command * descriptions. */ export default class Core { soap: Soap; timeDiff: number; serviceAddress?: { href: string; host: string; }; username?: string; password?: string; version?: string; /** * Call this function directly after instantiating a Core object. * @param serviceAddress An url object from url package - require('url'). * @param username Optional only if the device does NOT have a user. * @param password Optional only if the device does NOT have a password. */ init(serviceAddress: { href: string; host: string; }, username?: string, password?: string): void; /** * Private function for creating a SOAP request. * @param body The body of the xml. */ private createRequest; private buildRequest; /** * Returns the onvif device's time difference * {@link getSystemDateAndTime} must be called first to get an accurate time. */ getTimeDiff(): number; /** * It is possible for an endpoint to request a URL that can be used to retrieve the complete * schema and WSDL definitions of a device. The command gives in return a URL entry point * where all the necessary product specific WSDL and schema definitions can be retrieved. The * device shall provide a URL for WSDL and schema download through the GetWsdlUrl * command. */ getWsdlUrl(): Promise<{ raw?: boolean; soap?: string; parsed?: any; } | { soap: string; schemas: any; data: any; }>; /** * +++ I get an 'Action Failed' with Axis cameras. Hikvision works fine. * Returns a collection of the devices services and possibly their available capabilities. The * returned capability response message is untyped to allow future addition of services, service * revisions and service capabilities. All returned service capabilities shall be structured by * different namespaces which are supported by a device. * A device shall implement this method if any of the ONVIF compliant services implements the * GetServiceCapabilities. For making sure about the structure of GetServices response with * capabilities, please refer to Annex C. Example for GetServices Response with capabilities. * The version in GetServicesResponse shall contain the specification version number of the * corresponding service that is implemented by a device. * @param includeCapability The message contains a request for all services in the device and * possibly the capabilities for each service. If the Boolean * IncludeCapability is set, then the response shall include the services * capabilities. */ getServices(includeCapability?: boolean): Promise<{ raw?: boolean; soap?: string; parsed?: any; } | { soap: string; schemas: any; data: any; }>; /** * +++ I get an 'Action Failed' with Axis cameras. Hikvision works fine. * This command returns the capabilities of the device service. The service shall implement this * method if the device supports the GetServices method. */ getServiceCapabilities(): Promise<{ raw?: boolean; soap?: string; parsed?: any; } | { soap: string; schemas: any; data: any; }>; /** * This method provides a backward compatible interface for the base capabilities. Refer to * GetServices for a full set of capabilities. * Annex A describes how to interpret the indicated capability. Apart from the addresses, the * capabilities only reflect optional functions in this specification. */ getCapabilities(): Promise<{ raw?: boolean; soap?: string; parsed?: any; } | { soap: string; schemas: any; data: any; }>; /** * This operation is used by an endpoint to get the hostname from a device. The device shall * return its hostname configurations through the GetHostname command. */ getHostname(): Promise<{ raw?: boolean; soap?: string; parsed?: any; } | { soap: string; schemas: any; data: any; }>; /** * This operation sets the hostname on a device. It shall be possible to set the device hostname * configurations through the SetHostname command. Attention: a call to SetDNS may result in * overriding a previously set hostname. * A device shall accept strings formated according to RFC 1123 section 2.1 or alternatively to * RFC 952, other string shall be considered as invalid strings. * A device shall try to retrieve the name via DHCP when the HostnameFromDHCP capability is * set and an empty name string is provided. * @param name The host name. If Name is an empty string hostname * should be retrieved from DHCP, otherwise the specified Name * shall be used. */ setHostname(name: string): Promise<{ raw?: boolean; soap?: string; parsed?: any; } | { soap: string; schemas: any; data: any; }>; /** * This operation controls whether the hostname shall be retrieved from DHCP. * A device shall support this command if support is signalled via the HostnameFromDHCP * capability. Depending on the device implementation the change may only become effective * after a device reboot. A device shall accept the command independent whether it is currently * using DHCP to retrieve its IPv4 address or not. Note that the device is not required to retrieve * its hostname via DHCP while the device is not using DHCP for retrieving its IP address. In the * latter case the device may fall back to the statically set hostname. * @param fromDHCP True if the hostname shall be obtained via DHCP. */ setHostnameFromDHCP(fromDHCP?: boolean): Promise<{ raw?: boolean; soap?: string; parsed?: any; } | { soap: string; schemas: any; data: any; }>; /** * This operation gets the DNS settings from a device. The device shall return its DNS * configurations through the GetDNS command. */ getDNS(): Promise<{ data?: { GetDNSResponse: any; SearchDomain: any[]; DNSManual: { type: 'IPv4' | 'IPv6'; IP4Address: string; IP6Address: number; }[]; }; }>; /** * This operation sets the DNS settings on a device. It shall be possible to set the device DNS * configurations through the SetDNS command. * It is valid to set the FromDHCP flag while the device is not using DHCP to retrieve its IPv4 * address. * @param fromDHCP True if the DNS servers are obtained via DHCP. * @param searchDomain The domain(s) to search if the hostname is not * fully qualified. * @param DNSManual A list of manually given DNS servers */ setDNS(fromDHCP: boolean, searchDomain?: any[], DNSManual?: { type: 'IPv4' | 'IPv6'; IPv4Address?: string; IPv6Address?: string; }[]): Promise<{ raw?: boolean; soap?: string; parsed?: any; } | { soap: string; schemas: any; data: any; }>; /** * This operation gets the NTP settings from a device. If the device supports NTP, it shall be * possible to get the NTP server settings through the GetNTP command. */ getNTP(): Promise<{ raw?: boolean; soap?: string; parsed?: any; } | { soap: string; schemas: any; data: any; }>; /** * This operation sets the NTP settings on a device. If support for NTP is signalled via the NTP * capability, it shall be possible to set the NTP server settings through the SetNTP command. * A device shall accept string formated according to RFC 1123 section 2.1, other string shall be * considered as invalid strings. It is valid to set the FromDHCP flag while the device is not using * DHCP to retrieve its IPv4 address. * Changes to the NTP server list shall not affect the clock mode DateTimeType. Use * SetSystemDateAndTime to activate NTP operation. * @param fromDHCP True if the NTP servers are obtained via DHCP. * @param NTPManual A list of manually given NTP servers when they * not are obtained via DHCP. */ setNTP(fromDHCP: boolean, NTPManual?: any[]): Promise<{ raw?: boolean; soap?: string; parsed?: any; } | { soap: string; schemas: any; data: any; }>; /** * This operation gets the dynamic DNS settings from a device. If the device supports dynamic * DNS as specified in [RFC 2136] and [RFC 4702], it shall be possible to get the type, name * and TTL through the GetDynamicDNS command */ getDynamicDNS(): Promise<{ raw?: boolean; soap?: string; parsed?: any; } | { soap: string; schemas: any; data: any; }>; /** * * @param type The type of update. There are three possible types: the * device desires no update (NoUpdate), the device wants the * DHCP server to update (ServerUpdates) and the device does * the update itself (ClientUpdates). * @param name The DNS name in case of the device does the update. * @param ttl Time to live */ setDynamicDNS(type: 'NoUpdate' | 'ServerUpdates' | 'ClientUpdates', name?: string, ttl?: number): Promise<{ raw?: boolean; soap?: string; parsed?: any; } | { soap: string; schemas: any; data: any; }>; /** * This operation gets the network interface configuration from a device. The device shall support return of network interface configuration settings as defined by the NetworkInterface type through the GetNetworkInterfaces command. */ getNetworkInterfaces(): Promise<{ raw?: boolean; soap?: string; parsed?: any; } | { soap: string; schemas: any; data: any; }>; /** * This operation gets defined network protocols from a device. The device shall support the GetNetworkProtocols command returning configured network protocols. */ getNetworkProtocols(): Promise<{ raw?: boolean; soap?: string; parsed?: any; } | { soap: string; schemas: any; data: any; }>; /** * This operation gets the default gateway settings from a device. The device shall support the GetNetworkDefaultGateway command returning configured default gateway address(es). */ getNetworkDefaultGateway(): Promise<{ raw?: boolean; soap?: string; parsed?: any; } | { soap: string; schemas: any; data: any; }>; /** * This operation gets the zero-configuration from a device. If the device supports dynamic IP configuration according to [RFC3927], it shall support the return of IPv4 zero configuration address and status through the GetZeroConfiguration command. * Devices supporting zero configuration on more than one interface shall use the extension to list the additional interface settings. */ getZeroConfiguration(): Promise<{ raw?: boolean; soap?: string; parsed?: any; } | { soap: string; schemas: any; data: any; }>; /** * This operation gets the IP address filter settings from a device. If the device supports device access control based on IP filtering rules (denied or accepted ranges of IP addresses), the device shall support the GetIPAddressFilter command. */ getIPAddressFilter(): Promise<{ raw?: boolean; soap?: string; parsed?: any; } | { soap: string; schemas: any; data: any; }>; /** * This operation returns the IEEE802.11 capabilities. The device shall support this operation. * Not all do. */ getDot11Capabilities(): Promise<{ raw?: boolean; soap?: string; parsed?: any; } | { soap: string; schemas: any; data: any; }>; /** * This operation returns the status of a wireless network interface. The device shall support this command. * Not all do. * @param {string} interfaceToken Network reference token. * @param {callback=} callback Optional callback, instead of a Promise. */ getDot11Status(interfaceToken: string): Promise<{ raw?: boolean; soap?: string; parsed?: any; } | { soap: string; schemas: any; data: any; }>; /** * This operation returns a lists of the wireless networks in range of the device. A device should * support this operation. The following status can be returned for each network: * <ul> * <li>SSID (shall)</li> * <li>BSSID (should)</li> * <li>Authentication and key management suite(s) (should)</li> * <li>Pair cipher(s) (should)</li> * <li>Group cipher(s) (should)</li> * <li>Signal strength (should)</li> * </ul> * @param {string} interfaceToken Network reference token. */ scanAvailableDot11Networks(interfaceToken: string): Promise<{ raw?: boolean; soap?: string; parsed?: any; } | { soap: string; schemas: any; data: any; }>; /** * This operation gets device information, such as manufacturer, model and firmware version * from a device. The device shall support the return of device information through the * GetDeviceInformation command. */ getDeviceInformation(): Promise<{ raw?: boolean; soap?: string; parsed?: any; } | { soap: string; schemas: any; data: any; }>; /** * This operation is used to retrieve URIs from which system information may be downloaded * using HTTP. URIs may be returned for the following system information: * System Logs. Multiple system logs may be returned, of different types. The exact format of * the system logs is outside the scope of this specification. * Support Information. This consists of arbitrary device diagnostics information from a device. * The exact format of the diagnostic information is outside the scope of this specification. * System Backup. The received file is a backup file that can be used to restore the current * device configuration at a later date. The exact format of the backup configuration file is * outside the scope of this specification. * If the device allows retrieval of system logs, support information or system backup data, it * should make them available via HTTP GET. If it does, it shall support the GetSystemUris * command. */ getSystemUris(): Promise<{ raw?: boolean; soap?: string; parsed?: any; } | { soap: string; schemas: any; data: any; }>; /** * This interface has been deprecated. * A device shall implement this command if the capability * SystemBackup is signaled. For a replacement method see section 8.3.2 and 8.3.5. * This operation retrieves system backup configuration file(s) from a device. The backup is * returned with reference to a name and mime-type together with binary data. The format of the * backup configuration data is vendor specific. It is expected that after completion of the restore * operation the device is working on the same configuration as that of the time the configuration * was backed up. Note that the configuration of static IP addresses may differ. * Device vendors may put restrictions on the functionality to be restored. The detailed behavior * is outside the scope of this specification. * The backup configuration file(s) are transmitted through MTOM [MTOM]. */ getSystemBackup(): Promise<{ raw?: boolean; soap?: string; parsed?: any; } | { soap: string; schemas: any; data: any; }>; /** * This operation gets the device system date and time. * The device shall support the return of the daylight * saving setting and of the manual system date and time * (if applicable) or indication of NTP time (if applicable) * through the GetSystemDateAndTime command. * A device shall provide the UTCDateTime information although * the item is marked as optional to ensure backward compatibility. * This is required to be called for devices that * support the GetSystemDateAndTime SOAP method so * a time diff can be used in subsequent calls to * the device. */ getSystemDateAndTime(): Promise<{ data?: { GetSystemDateAndTimeResponse?: { SystemDateAndTime?: { DateTimeType?: string; DaylightSavings?: string; UTCDateTime?: { Time?: { Hour?: string; Minute?: string; Second?: string; }; Date?: { Day?: string; Month?: string; Year?: string; }; }; TimeZone?: { TZ?: string; }; }; }; }; }>; /** * Private function * @param sdt GetSystemDateAndTimeResponse converted to JSON. */ private parseGetSystemDateAndTime; /** * This operation gets a system log from the device. The exact format of the system logs is outside the scope of this standard. * @param logType Specifies the type of system log to get. * <ul> * <li>System: Indicates that a system log is requested.</li> * <li>Access: Indicates that a access log is requested.</li> * </ul> */ getSystemLog(logType: 'System' | 'Access'): Promise<{ raw?: boolean; soap?: string; parsed?: any; } | { soap: string; schemas: any; data: any; }>; /** * This operation gets arbitary device diagnostics information from the device. */ getSystemSupportInformation(): Promise<{ raw?: boolean; soap?: string; parsed?: any; } | { soap: string; schemas: any; data: any; }>; /** * This operation reboots the device. * @returns Contains the reboot message from the device (ie: Rebooting in 90 seconds). */ systemReboot(): Promise<{ raw?: boolean; soap?: string; parsed?: any; } | { soap: string; schemas: any; data: any; }>; /** * This operation requests the scope parameters of a device. The scope parameters are used in * the device discovery to match a probe message, see Section 7. The Scope parameters are of * two different types: * <ul> * <li>Fixed</li> * <li>Configurable</li> * </ul> * Fixed scope parameters are permanent device characteristics and cannot be removed * through the device management interface. The scope type is indicated in the scope list * returned in the get scope parameters response. A device shall support retrieval of discovery * scope parameters through the GetScopes command. As some scope parameters are * mandatory, the device shall return a non-empty scope list in the response. */ getScopes(): Promise<{ raw?: boolean; soap?: string; parsed?: any; } | { soap: string; schemas: any; data: any; }>; /** * This operation gets the geo location information of a device. A device that signals support for * GeoLocation via the capability GeoLocationEntities shall support the retrieval of geo location * information via this command. */ getGeoLocation(): Promise<{ raw?: boolean; soap?: string; parsed?: any; } | { soap: string; schemas: any; data: any; }>; /** * This operation gets the discovery mode of a device */ getDiscoveryMode(): Promise<{ raw?: boolean; soap?: string; parsed?: any; } | { soap: string; schemas: any; data: any; }>; /** * This operation gets the remote discovery mode of a device. See Section 7.4 for the definition of remote discovery extensions. A device that supports remote discovery shall support retrieval of the remote discovery mode setting through the GetRemoteDiscoveryMode command. */ getRemoteDiscoveryMode(): Promise<{ raw?: boolean; soap?: string; parsed?: any; } | { soap: string; schemas: any; data: any; }>; /** * This operation gets the remote DP address or addresses from a device. If the device supports remote discovery, as specified in Section 7.4, the device shall support retrieval of the remote DP address(es) through the GetDPAddresses command. */ getDPAddresses(): Promise<{ raw?: boolean; soap?: string; parsed?: any; } | { soap: string; schemas: any; data: any; }>; /** * Access to different services and sub-sets of services should be subject * to access control. The WS-Security framework gives the prerequisite for * end-point authentication. Authorization decisions can then be taken * using an access security policy. This standard does not mandate any * particular policy description format or security policy but this is * up to the device manufacturer or system provider to choose policy and * policy description format of choice. However, an access policy (in * arbitrary format) can be requested using this command. If the device * supports access policy settings based on WS-Security authentication, * then the device shall support this command. */ getAccessPolicy(): Promise<{ raw?: boolean; soap?: string; parsed?: any; } | { soap: string; schemas: any; data: any; }>; /** * This operation lists the registered users and corresponding credentials on a device. The device shall support retrieval of registered device users and their credentials for the user token through the GetUsers command. */ getUsers(): Promise<{ raw?: boolean; soap?: string; parsed?: any; } | { soap: string; schemas: any; data: any; }>; /** * This operation gets one IEEE 802.1X configuration parameter set from the device by * specifying the configuration token (Dot1XConfigurationToken). * The device shall support this command if support for IEEE 802.1X is signaled via the Security * Dot1X capability. * Regardless of whether the 802.1X method in the retrieved configuration has a password or * not, the device shall not include the Password element in the response. * @param dot1XConfigurationToken Dot1XConfigurationToken [ReferenceToken] */ getDot1XConfiguration(dot1XConfigurationToken: string): Promise<{ raw?: boolean; soap?: string; parsed?: any; } | { soap: string; schemas: any; data: any; }>; /** * This operation gets all the existing IEEE 802.1X configuration parameter sets from the device. * The device shall respond with all the IEEE 802.1X configurations so that the client can get to * know how many IEEE 802.1X configurations are existing and how they are configured. * The device shall support this command if support for IEEE 802.1X is signaled via the Security * Dot1X capability. * Regardless of whether the 802.1X method in the retrieved configuration has a password or * not, the device shall not include the Password element in the response. */ getDot1XConfigurations(): Promise<{ raw?: boolean; soap?: string; parsed?: any; } | { soap: string; schemas: any; data: any; }>; /** * This operation gets all device server certificates (including self-signed) for the purpose of TLS * authentication and all device client certificates for the purpose of IEEE 802.1X authentication. * This command lists only the TLS server certificates and IEEE 802.1X client certificates for the * device (neither trusted CA certificates nor trusted root certificates). The certificates are * returned as binary data. A device that supports TLS shall support this command and the * certificates shall be encoded using ASN.1 [X.681], [X.682], [X.683] DER [X.690] encoding * rules. */ getCertificates(): Promise<{ raw?: boolean; soap?: string; parsed?: any; } | { soap: string; schemas: any; data: any; }>; /** * CA certificates will be loaded into a device and be used for the sake of following two cases. * The one is for the purpose of TLS client authentication in TLS server function. The other one * is for the purpose of Authentication Server authentication in IEEE 802.1X function. This * operation gets all CA certificates loaded into a device. A device that supports either TLS client * authentication or IEEE 802.1X shall support this command and the returned certificates shall * be encoded using ASN.1 [X.681], [X.682], [X.683] DER [X.690] encoding rules. */ getCACertificates(): Promise<{ raw?: boolean; soap?: string; parsed?: any; } | { soap: string; schemas: any; data: any; }>; /** * This operation is specific to TLS functionality. This operation gets the status * (enabled/disabled) of the device TLS server certificates. A device that supports TLS shall * support this command. */ getCertificatesStatus(): Promise<{ raw?: boolean; soap?: string; parsed?: any; } | { soap: string; schemas: any; data: any; }>; /** * This operation is specific to TLS functionality. This operation gets the status * (enabled/disabled) of the device TLS client authentication. A device that supports TLS shall * support this command. */ getClientCertificateMode(): Promise<{ raw?: boolean; soap?: string; parsed?: any; } | { soap: string; schemas: any; data: any; }>; /** * This operation returns the configured remote user (if any). A device that signals support for * remote user handling via the Security Capability RemoteUserHandling shall support this * operation. The user is only valid for the WS-UserToken profile or as a HTTP / RTSP user. * The algorithm to use for deriving the password is described in section 5.12.3.1. */ getRemoteUser(): Promise<{ raw?: boolean; soap?: string; parsed?: any; } | { soap: string; schemas: any; data: any; }>; /** * A client can ask for the device service endpoint reference address property that can be used * to derive the password equivalent for remote user operation. The device should support the * GetEndpointReference command returning the address property of the device service * endpoint reference. */ getEndpointReference(): Promise<{ raw?: boolean; soap?: string; parsed?: any; } | { soap: string; schemas: any; data: any; }>; /** * This operation gets a list of all available relay outputs and their settings. */ getRelayOutputs(): Promise<{ raw?: boolean; soap?: string; parsed?: any; } | { soap: string; schemas: any; data: any; }>; }