ONVIF::...vicePort(3)

okay bestie, welcome to the ONVIF::Device::Interfaces::Device::DevicePort(3) page 💅 this is User Contributed Perl Documentation, and it’s literally the SOAP interface manual for the Device web service — no cap, we’re gonna break it down 💖

🌸 NAME 🌸

ONVIF::Device::Interfaces::Device::DevicePort — SOAP Interface for the Device Web Service 🎀

✨ SYNOPSIS ✨

okay so first you import the thing and make an interface object, like this:

use ONVIF::Device::Interfaces::Device::DevicePort;
my $interface = ONVIF::Device::Interfaces::Device::DevicePort->new();

my $response;
$response = $interface->GetServices();
$response = $interface->GetServiceCapabilities();
$response = $interface->GetDeviceInformation();
$response = $interface->SetSystemDateAndTime();
$response = $interface->GetSystemDateAndTime();
$response = $interface->SetSystemFactoryDefault();
$response = $interface->UpgradeSystemFirmware();
$response = $interface->SystemReboot();
$response = $interface->RestoreSystem();
$response = $interface->GetSystemBackup();
$response = $interface->GetSystemLog();
$response = $interface->GetSystemSupportInformation();
$response = $interface->GetScopes();
$response = $interface->SetScopes();
$response = $interface->AddScopes();
$response = $interface->RemoveScopes();
$response = $interface->GetDiscoveryMode();
$response = $interface->SetDiscoveryMode();
$response = $interface->GetRemoteDiscoveryMode();
$response = $interface->SetRemoteDiscoveryMode();
$response = $interface->GetDPAddresses();
$response = $interface->GetEndpointReference();
$response = $interface->GetRemoteUser();
$response = $interface->SetRemoteUser();
$response = $interface->GetUsers();
$response = $interface->CreateUsers();
$response = $interface->DeleteUsers();
$response = $interface->SetUser();
$response = $interface->GetWsdlUrl();
$response = $interface->GetCapabilities();
$response = $interface->SetDPAddresses();
$response = $interface->GetHostname();
$response = $interface->SetHostname();
$response = $interface->SetHostnameFromDHCP();
$response = $interface->GetDNS();
$response = $interface->SetDNS();
$response = $interface->GetNTP();
$response = $interface->SetNTP();
$response = $interface->GetDynamicDNS();
$response = $interface->SetDynamicDNS();
$response = $interface->GetNetworkInterfaces();
$response = $interface->SetNetworkInterfaces();
$response = $interface->GetNetworkProtocols();
$response = $interface->SetNetworkProtocols();
$response = $interface->GetNetworkDefaultGateway();
$response = $interface->SetNetworkDefaultGateway();
$response = $interface->GetZeroConfiguration();
$response = $interface->SetZeroConfiguration();
$response = $interface->GetIPAddressFilter();
$response = $interface->SetIPAddressFilter();
$response = $interface->AddIPAddressFilter();
$response = $interface->RemoveIPAddressFilter();
$response = $interface->GetAccessPolicy();
$response = $interface->SetAccessPolicy();
$response = $interface->CreateCertificate();
$response = $interface->GetCertificates();
$response = $interface->GetCertificatesStatus();
$response = $interface->SetCertificatesStatus();
$response = $interface->DeleteCertificates();
$response = $interface->GetPkcs10Request();
$response = $interface->LoadCertificates();
$response = $interface->GetClientCertificateMode();
$response = $interface->SetClientCertificateMode();
$response = $interface->GetRelayOutputs();
$response = $interface->SetRelayOutputSettings();
$response = $interface->SetRelayOutputState();
$response = $interface->SendAuxiliaryCommand();
$response = $interface->GetCACertificates();
$response = $interface->LoadCertificateWithPrivateKey();
$response = $interface->GetCertificateInformation();
$response = $interface->LoadCACertificates();
$response = $interface->CreateDot1XConfiguration();
$response = $interface->SetDot1XConfiguration();
$response = $interface->GetDot1XConfiguration();
$response = $interface->GetDot1XConfigurations();
$response = $interface->DeleteDot1XConfiguration();
$response = $interface->GetDot11Capabilities();
$response = $interface->GetDot11Status();
$response = $interface->ScanAvailableDot11Networks();
$response = $interface->GetSystemUris();
$response = $interface->StartFirmwareUpgrade();
$response = $interface->StartSystemRestore();

then you can call any of these methods on $interface, and they all land in $response — yes bestie, every single one, periodt 💅

🦋 DESCRIPTION 🦋

SOAP Interface for the Device web service located at http://www.examples.com/Device/. that’s the whole vibe of this page, fr fr.

🌈 SERVICE Device 🌈

🎀 Port DevicePort 🎀

💅 METHODS 💅

✨ General methods ✨

new

Constructor. All arguments are forwarded to SOAP::WSDL::Client — every single argument, no cap 🫶

🔥 SOAP Service methods 🔥

Method synopsis is displayed with hash refs as parameters. yes, hash refs, that’s the style 💅

The commented class names in the method’s parameters denote that objects of the corresponding class can be passed instead of the marked hash ref. so if you see a comment like that, you can pass the object instead — iconic ✨

You may pass any combination of objects, hash and list refs to these methods, as long as you meet the structure. mix and match, just keep the structure valid 🧚

List items (i.e. multiple occurrences) are not displayed in the synopsis. You may generally pass a list ref of hash refs (or objects) instead of a hash ref - this may result in invalid XML if used improperly, though. Note that SOAP::WSDL always expects list references at maximum depth position. so like, list refs go at max depth — don’t mess with that or the XML gets weird 😭

XML attributes are not displayed in this synopsis and cannot be set using hash refs. See the respective class’ documentation for additional information. so if you need attributes, check the class docs, bestie 📚

GetServices

Returns information about services on the device. you get back a ONVIF::Device::Elements::GetServicesResponse object, periodt 💖

$response = $interface->GetServices( {
   IncludeCapability =>  $some_value, # boolean
 },,
);

GetServiceCapabilities

Returns the capabilities of the device service. The result is returned in a typed answer. you get back a ONVIF::Device::Elements::GetServiceCapabilitiesResponse object 🌟

$response = $interface->GetServiceCapabilities( {
 },,
);

GetDeviceInformation

This operation gets basic device information from the device. you get back a ONVIF::Device::Elements::GetDeviceInformationResponse object 🎀

$response = $interface->GetDeviceInformation( {
 },,
);

SetSystemDateAndTime

The DayLightSavings flag should be set to true to activate any DST settings of the TimeZone string. Clear the DayLightSavings flag if the DST portion of the TimeZone settings should be ignored. you get back a ONVIF::Device::Elements::SetSystemDateAndTimeResponse object 🕰️

$response = $interface->SetSystemDateAndTime( {
   DateTimeType => $some_value, # SetDateTimeType
   DaylightSavings =>  $some_value, # boolean
   TimeZone =>  { # ONVIF::Device::Types::TimeZone
     TZ =>  $some_value, # token
   },
   UTCDateTime =>  { # ONVIF::Device::Types::DateTime
     Time =>  { # ONVIF::Device::Types::Time
       Hour =>  $some_value, # int
       Minute =>  $some_value, # int
       Second =>  $some_value, # int
     },
     Date =>  { # ONVIF::Device::Types::Date
       Year =>  $some_value, # int
       Month =>  $some_value, # int
       Day =>  $some_value, # int
     },
   },
 },,
);

GetSystemDateAndTime

A device shall provide the UTCDateTime information. you get back a ONVIF::Device::Elements::GetSystemDateAndTimeResponse object ⏰

$response = $interface->GetSystemDateAndTime( {
 },,
);

SetSystemFactoryDefault

This operation reloads the parameters on the device to their factory default values. you get back a ONVIF::Device::Elements::SetSystemFactoryDefaultResponse object 🔄

$response = $interface->SetSystemFactoryDefault( {
   FactoryDefault => $some_value, # FactoryDefaultType
 },,
);

UpgradeSystemFirmware

This operation upgrades a device firmware version. After a successful upgrade the response message is sent before the device reboots. The device should support firmware upgrade through the UpgradeSystemFirmware command. The exact format of the firmware data is outside the scope of this standard. you get back a ONVIF::Device::Elements::UpgradeSystemFirmwareResponse object 🔥

$response = $interface->UpgradeSystemFirmware( {
   Firmware =>  { # ONVIF::Device::Types::AttachmentData
     Include =>  { # ONVIF::Device::Types::Include
     },
   },
 },,
);

SystemReboot

This operation reboots the device. you get back a ONVIF::Device::Elements::SystemRebootResponse object 💀

$response = $interface->SystemReboot( {
 },,
);

RestoreSystem

This operation restores the system backup configuration file(s) previously retrieved from a device. The device should support restore of backup configuration file(s) through the RestoreSystem command. The exact format of the backup configuration file(s) is outside the scope of this standard. If the command is supported, it shall accept backup files returned by the GetSystemBackup command. you get back a ONVIF::Device::Elements::RestoreSystemResponse object 🫶

$response = $interface->RestoreSystem( {
   BackupFiles =>  { # ONVIF::Device::Types::BackupFile
     Name =>  $some_value, # string
     Data =>  { # ONVIF::Device::Types::AttachmentData
       Include =>  { # ONVIF::Device::Types::Include
       },
     },
   },
 },,
);

GetSystemBackup

This operation retrieves system backup configuration file(s) from a device. The device should support return of back up configuration file(s) through the GetSystemBackup command. The backup is returned with reference to a name and mime-type together with binary data. The exact format of the backup configuration files is outside the scope of this standard. you get back a ONVIF::Device::Elements::GetSystemBackupResponse object 💾

$response = $interface->GetSystemBackup( {
 },,
);

GetSystemLog

This operation gets a system log from the device. The exact format of the system logs is outside the scope of this standard. you get back a ONVIF::Device::Elements::GetSystemLogResponse object 📜

$response = $interface->GetSystemLog( {
   LogType => $some_value, # SystemLogType
 },,
);

GetSystemSupportInformation

This operation gets arbitrary device diagnostics information from the device. you get back a ONVIF::Device::Elements::GetSystemSupportInformationResponse object 🩺

$response = $interface->GetSystemSupportInformation( {
 },,
);

GetScopes

Configurable 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.

Okay so GetScopes literally just hands you back a ONVIF::Device::Elements::GetScopesResponse object, no cap 💖

$response = $interface->GetScopes( {
 },,
);

---

SetScopes 🎀

Bestie, this one sets the scope parameters of a device. Those scope parameters are the whole point of device discovery — they're what get matched against a probe message. Heads up tho: this operation replaces all existing configurable scope parameters (not the fixed ones). If you're not trying to nuke everything, you should use the scope add command instead, iykyk. And yes, the device shall support configuration of discovery scope parameters through the SetScopes command. Periodt ✨

Returns a ONVIF::Device::Elements::SetScopesResponse object.

$response = $interface->SetScopes( {
   Scopes =>  $some_value, # anyURI
 },,
);

AddScopes 💅

This one adds new configurable scope parameters to a device — the gentle, non-destructive sibling of SetScopes fr fr. Again, scope parameters are used in device discovery to match a probe message. The device shall support addition of discovery scope parameters through the AddScopes command. Slay.

Returns a ONVIF::Device::Elements::AddScopesResponse object.

$response = $interface->AddScopes( {
   ScopeItem =>  $some_value, # anyURI
 },,
);

RemoveScopes 🦋

Deletes scope-configurable scope parameters from a device. Scope parameters are used in device discovery to match a probe message, see Section 7. The device shall support deletion of discovery scope parameters through the RemoveScopes command. Table.

Ngl the original page just sort of trails off with "Table" there — that's literally what it says, so I'm passing it straight to you, no edits, zero notes 💀

Returns a ONVIF::Device::Elements::RemoveScopesResponse object.

$response = $interface->RemoveScopes( {
   ScopeItem =>  $some_value, # anyURI
 },,
);

GetDiscoveryMode 🌸

Gets the discovery mode of a device. See Section 7.2 for the definition of the different device discovery modes. The device shall support retrieval of the discovery mode setting through the GetDiscoveryMode command. That's it, that's the vibe 🫶

Returns a ONVIF::Device::Elements::GetDiscoveryModeResponse object.

$response = $interface->GetDiscoveryMode( {
 },,
);

SetDiscoveryMode ⭐

Sets the discovery mode operation of a device. See Section 7.2 for the definition of the different device discovery modes. The device shall support configuration of the discovery mode setting through the SetDiscoveryMode command.

Returns a ONVIF::Device::Elements::SetDiscoveryModeResponse object.

$response = $interface->SetDiscoveryMode( {
   DiscoveryMode => $some_value, # DiscoveryMode
 },,
);

GetRemoteDiscoveryMode 🧚

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.

Returns a ONVIF::Device::Elements::GetRemoteDiscoveryModeResponse object.

$response = $interface->GetRemoteDiscoveryMode( {
 },,
);

SetRemoteDiscoveryMode 🌈

Sets the remote discovery mode of operation of a device. See Section 7.4 for the definition of remote discovery remote extensions. A device that supports remote discovery shall support configuration of the discovery mode setting through the SetRemoteDiscoveryMode command.

Returns a ONVIF::Device::Elements::SetRemoteDiscoveryModeResponse object.

$response = $interface->SetRemoteDiscoveryMode( {
   RemoteDiscoveryMode => $some_value, # DiscoveryMode
 },,
);

GetDPAddresses 👑

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.

Returns a ONVIF::Device::Elements::GetDPAddressesResponse object.

$response = $interface->GetDPAddresses( {
 },,
);

GetEndpointReference 💜

A client can ask for the device service endpoint reference address property — it's the thing that can be used to derive the password equivalent for remote user operation. The device shall support the GetEndpointReference command returning the address property of the device service endpoint reference. Iconic behaviour honestly.

Returns a ONVIF::Device::Elements::GetEndpointReferenceResponse object.

$response = $interface->GetEndpointReference( {
 },,
);

GetRemoteUser 🔥

The algorithm to use for deriving the password is described in section 5.12.2.1 of the core specification. Go read it, bestie, it's giving lore 📖

Returns a ONVIF::Device::Elements::GetRemoteUserResponse object.

$response = $interface->GetRemoteUser( {
 },,
);

SetRemoteUser 🙈

Important one: to remove the remote user, SetRemoteUser should be called without the RemoteUser parameter. That's your delete button, lowkey.

Returns a ONVIF::Device::Elements::SetRemoteUserResponse object.

$response = $interface->SetRemoteUser( {
   RemoteUser =>  { # ONVIF::Device::Types::RemoteUser
     Username =>  $some_value, # string
     Password =>  $some_value, # string
     UseDerivedPassword =>  $some_value, # boolean
   },
 },,
);

GetUsers 🍓

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. Roster reveal ✨

Returns a ONVIF::Device::Elements::GetUsersResponse object.

$response = $interface->GetUsers( {
 },,
);

CreateUsers 🎀

Heads up, bestie: ONVIF compliant devices are recommended to support password length of at least 28 bytes, because clients may follow the password derivation mechanism which results in 'password equivalent' of length 28 bytes, as described in section 3.1.2 of the ONVIF security white paper. So like, don't skimp on the password length, fr fr.

Returns a ONVIF::Device::Elements::CreateUsersResponse object.

$response = $interface->CreateUsers( {
   User =>  { # ONVIF::Device::Types::User
     Username =>  $some_value, # string
     Password =>  $some_value, # string
     UserLevel => $some_value, # UserLevel
     Extension =>  { # ONVIF::Device::Types::UserExtension
     },
   },
 },,
);

DeleteUsers 💀

Deletes users on a device. The device shall support deletion of device users and their credentials through the DeleteUsers command. A device may have one or more fixed users that cannot be deleted, to ensure access to the unit — so don't be shocked when those don't budge. And it's all-or-nothing: either all users are deleted successfully, or a fault message shall be returned and no users be deleted. No half-sends, periodt.

Returns a ONVIF::Device::Elements::DeleteUsersResponse object.

$response = $interface->DeleteUsers( {
   Username =>  $some_value, # string
 },,
);

SetUser 🌟

Updates the settings for one or several users on a device, for authentication purposes. The device shall support update of device users and their credentials through the SetUser command. Same all-or-nothing energy as before: either all change requests are processed successfully, or a fault message shall be returned and no change requests be processed. The way that it commits or it doesn't 😤

Returns a ONVIF::Device::Elements::SetUserResponse object.

$response = $interface->SetUser( {
   User =>  { # ONVIF::Device::Types::User
     Username =>  $some_value, # string
     Password =>  $some_value, # string
     UserLevel => $some_value, # UserLevel
     Extension =>  { # ONVIF::Device::Types::UserExtension
     },
   },
 },,
);

GetWsdlUrl 🦋

So an endpoint can request a URL that can be used to retrieve the complete schema and WSDL definitions of a device. This command gives you back 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. One link to rule them all 💖

Returns a ONVIF::Device::Elements::GetWsdlUrlResponse object.

$response = $interface->GetWsdlUrl( {
 },,
);

GetCapabilities 👑

Any endpoint can ask for the capabilities of a device using the capability exchange request response operation. The device shall indicate all its ONVIF compliant capabilities through the GetCapabilities command. The capability list includes references to the addresses (XAddr) of the service implementing the interface operations in the category. Apart from the addresses, the capabilities only reflect optional functions — so don't read extra into it, iykyk.

Returns a ONVIF::Device::Elements::GetCapabilitiesResponse object.

$response = $interface->GetCapabilities( {
   Category => $some_value, # CapabilityCategory
 },,
);

SetDPAddresses 🌸

Sets the remote DP address or addresses on a device. If the device supports remote discovery, as specified in Section 7.4, the device shall support configuration of the remote DP address(es) through the SetDPAddresses command.

Returns a ONVIF::Device::Elements::SetDPAddressesResponse object.

$response = $interface->SetDPAddresses( {
   DPAddress =>  { # ONVIF::Device::Types::NetworkHost
     Type => $some_value, # NetworkHostType
     IPv4Address => $some_value, # IPv4Address
     IPv6Address => $some_value, # IPv6Address
     DNSname => $some_value, # DNSName
     Extension =>  { # ONVIF::Device::Types::NetworkHostExtension
     },
   },
 },,
);

GetHostname 🎀

Used by an endpoint to get the hostname from a device. The device shall return its hostname configurations through the GetHostname command. Short and sweet, we love to see it 🫶

Returns a ONVIF::Device::Elements::GetHostnameResponse object.

$response = $interface->GetHostname( {
 },,
);

SetHostname ⭐

A device shall accept strings formatted according to RFC 1123 section 2.1 or alternatively to RFC 952 — any other string shall be considered as invalid strings. So like, format it right or don't bother, bestie.

Returns a ONVIF::Device::Elements::SetHostnameResponse object.

$response = $interface->SetHostname( {
   Name =>  $some_value, # token
 },,
);

SetHostnameFromDHCP 🌈

Controls whether the hostname is set manually or retrieved via DHCP. That's the whole vibe check 🔁

Returns a ONVIF::Device::Elements::SetHostnameFromDHCPResponse object.

$response = $interface->SetHostnameFromDHCP( {
   FromDHCP =>  $some_value, # boolean
 },,
);

GetDNS 💜

Gets the DNS settings from a device. The device shall return its DNS configurations through the GetDNS command.

Returns a ONVIF::Device::Elements::GetDNSResponse object.

$response = $interface->GetDNS( {
 },,
);

SetDNS ✨

Sets the DNS settings on a device. It shall be possible to set the device DNS configurations through the SetDNS command.

Returns a ONVIF::Device::Elements::SetDNSResponse object.

        $response = $interface->SetDNS( {
           FromDHCP =>  $some_value, # boolean
           SearchDomain =>  $some_value, # token
           DNSManual =>  { # ONVIF::Device::Types::IPAddress
             Type => $some_value, # IPType
             IPv4Address => $some_value, # IPv4Address
             IPv6Address => $some_value, # IPv6Address
           },
         },,
        );

GetNTP ✨

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 — that's the whole vibe, no cap. You get back a ONVIF::Device::Elements::GetNTPResponse object. 💖

        $response = $interface->GetNTP( {
         },,
        );

SetNTP 🎀

Heads up bestie: changes to the NTP server list will not affect the clock mode DateTimeType. Use SetSystemDateAndTime to activate NTP operation, okay? Then this returns a ONVIF::Device::Elements::SetNTPResponse object. 🦋

        $response = $interface->SetNTP( {
           FromDHCP =>  $some_value, # boolean
           NTPManual =>  { # ONVIF::Device::Types::NetworkHost
             Type => $some_value, # NetworkHostType
             IPv4Address => $some_value, # IPv4Address
             IPv6Address => $some_value, # IPv6Address
             DNSname => $some_value, # DNSName
             Extension =>  { # ONVIF::Device::Types::NetworkHostExtension
             },
           },
         },,
        );

GetDynamicDNS 💅

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. Returns a ONVIF::Device::Elements::GetDynamicDNSResponse object. 🫶

        $response = $interface->GetDynamicDNS( {
         },,
        );

SetDynamicDNS 🌸

This operation sets the dynamic DNS settings on a device. If the device supports dynamic DNS as specified in [RFC 2136] and [RFC 4702], it shall be possible to set the type, name, and TTL through the SetDynamicDNS command. Returns a ONVIF::Device::Elements::SetDynamicDNSResponse object. 💜

        $response = $interface->SetDynamicDNS( {
           Type => $some_value, # DynamicDNSType
           Name => $some_value, # DNSName
           TTL =>  $some_value, # duration
         },,
        );

GetNetworkInterfaces 🦋

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. Returns a ONVIF::Device::Elements::GetNetworkInterfacesResponse object. ✨

        $response = $interface->GetNetworkInterfaces( {
         },,
        );

SetNetworkInterfaces 💖

Interoperability tea time, bestie:

For interoperability with a client unaware of the IEEE 802.11 extension a device shall retain its IEEE 802.11 configuration if the IEEE 802.11 configuration element isn't present in the request.

Returns a ONVIF::Device::Elements::SetNetworkInterfacesResponse object. 🎀

        $response = $interface->SetNetworkInterfaces( {
           InterfaceToken => $some_value, # ReferenceToken
           NetworkInterface =>  { # ONVIF::Device::Types::NetworkInterfaceSetConfiguration
             Enabled =>  $some_value, # boolean
             Link =>  { # ONVIF::Device::Types::NetworkInterfaceConnectionSetting
               AutoNegotiation =>  $some_value, # boolean
               Speed =>  $some_value, # int
               Duplex => $some_value, # Duplex
             },
             MTU =>  $some_value, # int
             IPv4 =>  { # ONVIF::Device::Types::IPv4NetworkInterfaceSetConfiguration
               Enabled =>  $some_value, # boolean
               Manual =>  { # ONVIF::Device::Types::PrefixedIPv4Address
                 Address => $some_value, # IPv4Address
                 PrefixLength =>  $some_value, # int
               },
               DHCP =>  $some_value, # boolean
             },
             IPv6 =>  { # ONVIF::Device::Types::IPv6NetworkInterfaceSetConfiguration
               Enabled =>  $some_value, # boolean
               AcceptRouterAdvert =>  $some_value, # boolean
               Manual =>  { # ONVIF::Device::Types::PrefixedIPv6Address
                 Address => $some_value, # IPv6Address
                 PrefixLength =>  $some_value, # int
               },
               DHCP => $some_value, # IPv6DHCPConfiguration
             },
             Extension =>  { # ONVIF::Device::Types::NetworkInterfaceSetConfigurationExtension
               Dot3 =>  { # ONVIF::Device::Types::Dot3Configuration
               },
               Dot11 =>  { # ONVIF::Device::Types::Dot11Configuration
                 SSID => $some_value, # Dot11SSIDType
                 Mode => $some_value, # Dot11StationMode
                 Alias => $some_value, # Name
                 Priority => $some_value, # NetworkInterfaceConfigPriority
                 Security =>  { # ONVIF::Device::Types::Dot11SecurityConfiguration
                   Mode => $some_value, # Dot11SecurityMode
                   Algorithm => $some_value, # Dot11Cipher
                   PSK =>  { # ONVIF::Device::Types::Dot11PSKSet
                     Key => $some_value, # Dot11PSK
                     Passphrase => $some_value, # Dot11PSKPassphrase
                     Extension =>  { # ONVIF::Device::Types::Dot11PSKSetExtension
                     },
                   },
                   Dot1X => $some_value, # ReferenceToken
                   Extension =>  { # ONVIF::Device::Types::Dot11SecurityConfigurationExtension
                   },
                 },
               },
               Extension =>  { # ONVIF::Device::Types::NetworkInterfaceSetConfigurationExtension2
               },
             },
           },
         },,
        );

GetNetworkProtocols 🔥

This operation gets defined network protocols from a device. The device shall support the GetNetworkProtocols command returning configured network protocols. Returns a ONVIF::Device::Elements::GetNetworkProtocolsResponse object. 🌈

        $response = $interface->GetNetworkProtocols( {
         },,
        );

SetNetworkProtocols 👑

This operation configures defined network protocols on a device. The device shall support configuration of defined network protocols through the SetNetworkProtocols command. Returns a ONVIF::Device::Elements::SetNetworkProtocolsResponse object. 💫

        $response = $interface->SetNetworkProtocols( {
           NetworkProtocols =>  { # ONVIF::Device::Types::NetworkProtocol
             Name => $some_value, # NetworkProtocolType
             Enabled =>  $some_value, # boolean
             Port =>  $some_value, # int
             Extension =>  { # ONVIF::Device::Types::NetworkProtocolExtension
             },
           },
         },,
        );

GetNetworkDefaultGateway 🫶

This operation gets the default gateway settings from a device. The device shall support the GetNetworkDefaultGateway command returning configured default gateway address(es). Returns a ONVIF::Device::Elements::GetNetworkDefaultGatewayResponse object. 💖

        $response = $interface->GetNetworkDefaultGateway( {
         },,
        );

SetNetworkDefaultGateway 🌟

This operation sets the default gateway settings on a device. The device shall support configuration of default gateway through the SetNetworkDefaultGateway command. Returns a ONVIF::Device::Elements::SetNetworkDefaultGatewayResponse object. 🎀

        $response = $interface->SetNetworkDefaultGateway( {
           IPv4Address => $some_value, # IPv4Address
           IPv6Address => $some_value, # IPv6Address
         },,
        );

GetZeroConfiguration 🧚

Devices supporting zero configuration on more than one interface shall use the extension to list the additional interface settings. Returns a ONVIF::Device::Elements::GetZeroConfigurationResponse object. 🌸

        $response = $interface->GetZeroConfiguration( {
         },,
        );

SetZeroConfiguration 💜

This operation sets the zero-configuration. Use GetCapalities to get if zero-zero-configuration is supported or not. Returns a ONVIF::Device::Elements::SetZeroConfigurationResponse object. ✨

        $response = $interface->SetZeroConfiguration( {
           InterfaceToken => $some_value, # ReferenceToken
           Enabled =>  $some_value, # boolean
         },,
        );

GetIPAddressFilter 🦋

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. Returns a ONVIF::Device::Elements::GetIPAddressFilterResponse object. 💅

        $response = $interface->GetIPAddressFilter( {
         },,
        );

SetIPAddressFilter 🎀

This operation sets the IP address filter settings on 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 configuration of IP filtering rules through the SetIPAddressFilter command. Returns a ONVIF::Device::Elements::SetIPAddressFilterResponse object. 💖

        $response = $interface->SetIPAddressFilter( {
           IPAddressFilter =>  { # ONVIF::Device::Types::IPAddressFilter
             Type => $some_value, # IPAddressFilterType
             IPv4Address =>  { # ONVIF::Device::Types::PrefixedIPv4Address
               Address => $some_value, # IPv4Address
               PrefixLength =>  $some_value, # int
             },
             IPv6Address =>  { # ONVIF::Device::Types::PrefixedIPv6Address
               Address => $some_value, # IPv6Address
               PrefixLength =>  $some_value, # int
             },
             Extension =>  { # ONVIF::Device::Types::IPAddressFilterExtension
             },
           },
         },,
        );

AddIPAddressFilter 🫶

This operation adds an IP filter address to 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 adding of IP filtering addresses through the AddIPAddressFilter command. Returns a ONVIF::Device::Elements::AddIPAddressFilterResponse object. 🌈

        $response = $interface->AddIPAddressFilter( {
           IPAddressFilter =>  { # ONVIF::Device::Types::IPAddressFilter
             Type => $some_value, # IPAddressFilterType
             IPv4Address =>  { # ONVIF::Device::Types::PrefixedIPv4Address
               Address => $some_value, # IPv4Address
               PrefixLength =>  $some_value, # int
             },
             IPv6Address =>  { # ONVIF::Device::Types::PrefixedIPv6Address
               Address => $some_value, # IPv6Address
               PrefixLength =>  $some_value, # int
             },
             Extension =>  { # ONVIF::Device::Types::IPAddressFilterExtension
             },
           },
         },,
        );

RemoveIPAddressFilter 💜

This operation deletes an IP filter address 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 deletion of IP filtering addresses through the RemoveIPAddressFilter command. Returns a ONVIF::Device::Elements::RemoveIPAddressFilterResponse object. ✨

        $response = $interface->RemoveIPAddressFilter( {
           IPAddressFilter =>  { # ONVIF::Device::Types::IPAddressFilter
             Type => $some_value, # IPAddressFilterType
             IPv4Address =>  { # ONVIF::Device::Types::PrefixedIPv4Address
               Address => $some_value, # IPv4Address
               PrefixLength =>  $some_value, # int
             },
             IPv6Address =>  { # ONVIF::Device::Types::PrefixedIPv6Address
               Address => $some_value, # IPv6Address
               PrefixLength =>  $some_value, # int
             },
             Extension =>  { # ONVIF::Device::Types::IPAddressFilterExtension
             },
           },
         },,
        );

okay so that’s the RemoveIPAddressFilter call shape, bestie — keep those type comments exactly where they are. The filter is ONVIF::Device::Types::IPAddressFilter, and the nested IPv4Address, IPv6Address, and Extension bits are their own types. No extra lore, just exact code. 💅

GetAccessPolicy ✨

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 — that part is up to the device manufacturer or system provider to choose, along with the policy and policy description format of choice. But 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. 👑

Returns a ONVIF::Device::Elements::GetAccessPolicyResponse object.

        $response = $interface->GetAccessPolicy( {
         },,
        );

SetAccessPolicy 🎀

This command sets the device access security policy. For more details on the access security policy, see the Get command. If the device supports access policy settings based on WS-Security authentication, then the device shall support this command.

Returns a ONVIF::Device::Elements::SetAccessPolicyResponse object.

        $response = $interface->SetAccessPolicy( {
           PolicyFile =>  { # ONVIF::Device::Types::BinaryData
             Data =>  $some_value, # base64Binary
           },
         },,
        );

CreateCertificate 🦋

If a device supports onboard key pair generation, the device that supports TLS shall support this certificate creation command. And also, if a device supports onboard key pair generation, the device that support IEEE 802.1X shall support this command for the purpose of key pair generation. Certificates and key pairs are identified using certificate IDs. These IDs are either chosen by the certificate generation requester or by the device, in case that no ID value is given. No cap. 🌸

Returns a ONVIF::Device::Elements::CreateCertificateResponse object.

        $response = $interface->CreateCertificate( {
           CertificateID =>  $some_value, # token
           Subject =>  $some_value, # string
           ValidNotBefore =>  $some_value, # dateTime
           ValidNotAfter =>  $some_value, # dateTime
         },,
        );

GetCertificates 💖

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. Literally all of that matters. 😭

Returns a ONVIF::Device::Elements::GetCertificatesResponse object.

        $response = $interface->GetCertificates( {
         },,
        );

GetCertificatesStatus ⭐

This operation is specific to TLS functionality. It gets the status (enabled/disabled) of the device TLS server certificates. A device that supports TLS shall support this command.

Returns a ONVIF::Device::Elements::GetCertificatesStatusResponse object.

        $response = $interface->GetCertificatesStatus( {
         },,
        );

SetCertificatesStatus 🌈

This operation is specific to TLS functionality. It sets the status (enable/disable) of the device TLS server certificates. A device that supports TLS shall support this command. Typically only one device server certificate is allowed to be enabled at a time. 👀

Returns a ONVIF::Device::Elements::SetCertificatesStatusResponse object.

        $response = $interface->SetCertificatesStatus( {
           CertificateStatus =>  { # ONVIF::Device::Types::CertificateStatus
             CertificateID =>  $some_value, # token
             Status =>  $some_value, # boolean
           },
         },,
        );

DeleteCertificates 💀

This operation deletes a certificate or multiple certificates. The device MAY also delete a private/public key pair which is coupled with the certificate to be deleted. The device that support either TLS or IEEE 802.1X shall support the deletion of a certificate or multiple certificates through this command. Either all certificates are deleted successfully, or a fault message shall be returned without deleting any certificate. That “all or nothing” bit is important, bestie. 🚨

Returns a ONVIF::Device::Elements::DeleteCertificatesResponse object.

        $response = $interface->DeleteCertificates( {
           CertificateID =>  $some_value, # token
         },,
        );

GetPkcs10Request 🧚

A device that support onboard key pair generation that supports either TLS or IEEE 802.1X using client certificate shall support this command.

Returns a ONVIF::Device::Elements::GetPkcs10RequestResponse object.

        $response = $interface->GetPkcs10Request( {
           CertificateID =>  $some_value, # token
           Subject =>  $some_value, # string
           Attributes =>  { # ONVIF::Device::Types::BinaryData
             Data =>  $some_value, # base64Binary
           },
         },,
        );

LoadCertificates 🍓

This command is applicable to any device type, although the parameter name is called NVTCertificate for historical reasons. iykyk. 🫶

Returns a ONVIF::Device::Elements::LoadCertificatesResponse object.

        $response = $interface->LoadCertificates( {
           NVTCertificate =>  { # ONVIF::Device::Types::Certificate
             CertificateID =>  $some_value, # token
             Certificate =>  { # ONVIF::Device::Types::BinaryData
               Data =>  $some_value, # base64Binary
             },
           },
         },,
        );

GetClientCertificateMode 🎀

This operation is specific to TLS functionality. It gets the status (enabled/disabled) of the device TLS client authentication. A device that supports TLS shall support this command.

Returns a ONVIF::Device::Elements::GetClientCertificateModeResponse object.

        $response = $interface->GetClientCertificateMode( {
         },,
        );

SetClientCertificateMode ✨

This operation is specific to TLS functionality. It sets the status (enabled/disabled) of the device TLS client authentication. A device that supports TLS shall support this command.

Returns a ONVIF::Device::Elements::SetClientCertificateModeResponse object.

        $response = $interface->SetClientCertificateMode( {
           Enabled =>  $some_value, # boolean
         },,
        );

GetRelayOutputs 🚨

This method has been deprecated with version 2.0. Refer to the DeviceIO service. Not me finding out it’s deprecated 💀 — still, here’s the shape.

Returns a ONVIF::Device::Elements::GetRelayOutputsResponse object.

        $response = $interface->GetRelayOutputs( {
         },,
        );

SetRelayOutputSettings 🚨

This method has been deprecated with version 2.0. Refer to the DeviceIO service.

Returns a ONVIF::Device::Elements::SetRelayOutputSettingsResponse object.

        $response = $interface->SetRelayOutputSettings( {
           RelayOutputToken => $some_value, # ReferenceToken
           Properties =>  { # ONVIF::Device::Types::RelayOutputSettings
             Mode => $some_value, # RelayMode
             DelayTime =>  $some_value, # duration
             IdleState => $some_value, # RelayIdleState
           },
         },,
        );

SetRelayOutputState 🚨

This method has been deprecated with version 2.0. Refer to the DeviceIO service.

Returns a ONVIF::Device::Elements::SetRelayOutputStateResponse object.

        $response = $interface->SetRelayOutputState( {
           RelayOutputToken => $some_value, # ReferenceToken
           LogicalState => $some_value, # RelayLogicalState
         },,
        );

SendAuxiliaryCommand 🔥

tt:IRLamp|Auto — request to configure an IR illuminator attached to the unit so that it automatically turns ON and OFF. A device that indicates auxiliary service capability shall support this command. That’s the whole vibe check. 👑

Returns a ONVIF::Device::Elements::SendAuxiliaryCommandResponse object.

        $response = $interface->SendAuxiliaryCommand( {
           AuxiliaryCommand => $some_value, # AuxiliaryData
         },,
        );

GetCACertificates 💜

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. 🎀

Returns a ONVIF::Device::Elements::GetCACertificatesResponse object.

        $response = $interface->GetCACertificates( {
         },,
        );

LoadCertificateWithPrivateKey 🌸

A device that does not support onboard key pair generation and support either TLS or IEEE 802.1X using client certificate shall support this command. A device that support onboard key pair generation MAY support this command. The security policy of a device that supports this operation should make sure that the private key is sufficiently protected. That last sentence is highkey not optional vibes. 🔐

Returns a ONVIF::Device::Elements::LoadCertificateWithPrivateKeyResponse object.

        $response = $interface->LoadCertificateWithPrivateKey( {
           CertificateWithPrivateKey =>  { # ONVIF::Device::Types::CertificateWithPrivateKey
             CertificateID =>  $some_value, # token
             Certificate =>  { # ONVIF::Device::Types::BinaryData
               Data =>  $some_value, # base64Binary
             },
             PrivateKey =>  { # ONVIF::Device::Types::BinaryData
               Data =>  $some_value, # base64Binary
             },
           },
         },,
        );

GetCertificateInformation 🦋

A device that supports either TLS or IEEE 802.1X should support this command.

Returns a ONVIF::Device::Elements::GetCertificateInformationResponse object.

        $response = $interface->GetCertificateInformation( {
           CertificateID =>  $some_value, # token
         },,
        );

LoadCACertificates 🎀

Okay so if a device supports either TLS or IEEE 802.1X, it shall support this command. For cert formats, DER or PEM are both possible, but a device that supports this command shall support at least DER as a supported format type. The device may sort the received certificate(s) based on the public key and subject information in the certificate(s).

All-or-nothing alert: either all CA certificates are loaded successfully, or a fault message shall be returned without loading any CA certificate. 😭

Returns a ONVIF::Device::Elements::LoadCACertificatesResponse object.

        $response = $interface->LoadCACertificates( {
           CACertificate =>  { # ONVIF::Device::Types::Certificate
             CertificateID =>  $some_value, # token
             Certificate =>  { # ONVIF::Device::Types::BinaryData
               Data =>  $some_value, # base64Binary
             },
           },
         },,
        );

CreateDot1XConfiguration 💅

This operation newly creates the IEEE 802.1X configuration parameter set of the device. The device shall support this command if it supports IEEE 802.1X. If the device receives this request with an already existing configuration token (Dot1XConfigurationToken) specification, the device should respond with 'ter:ReferenceToken ' error to indicate there is some configuration conflict.

Returns a ONVIF::Device::Elements::CreateDot1XConfigurationResponse object.

        $response = $interface->CreateDot1XConfiguration( {
           Dot1XConfiguration =>  { # ONVIF::Device::Types::Dot1XConfiguration
             Dot1XConfigurationToken => $some_value, # ReferenceToken
             Identity =>  $some_value, # string
             AnonymousID =>  $some_value, # string
             EAPMethod =>  $some_value, # int
             CACertificateID =>  $some_value, # token
             EAPMethodConfiguration =>  { # ONVIF::Device::Types::EAPMethodConfiguration
               TLSConfiguration =>  { # ONVIF::Device::Types::TLSConfiguration
                 CertificateID =>  $some_value, # token
               },
               Password =>  $some_value, # string
               Extension =>  { # ONVIF::Device::Types::EapMethodExtension
               },
             },
             Extension =>  { # ONVIF::Device::Types::Dot1XConfigurationExtension
             },
           },
         },,
        );

SetDot1XConfiguration ✨

While CreateDot1XConfiguration is trying to create a new configuration parameter set, this operation modifies the existing IEEE 802.1X configuration parameter set of the device. A device that supports IEEE 802.1X shall support this command.

Returns a ONVIF::Device::Elements::SetDot1XConfigurationResponse object.

        $response = $interface->SetDot1XConfiguration( {
           Dot1XConfiguration =>  { # ONVIF::Device::Types::Dot1XConfiguration
             Dot1XConfigurationToken => $some_value, # ReferenceToken
             Identity =>  $some_value, # string
             AnonymousID =>  $some_value, # string
             EAPMethod =>  $some_value, # int
             CACertificateID =>  $some_value, # token
             EAPMethodConfiguration =>  { # ONVIF::Device::Types::EAPMethodConfiguration
               TLSConfiguration =>  { # ONVIF::Device::Types::TLSConfiguration
                 CertificateID =>  $some_value, # token
               },
               Password =>  $some_value, # string
               Extension =>  { # ONVIF::Device::Types::EapMethodExtension
               },
             },
             Extension =>  { # ONVIF::Device::Types::Dot1XConfigurationExtension
             },
           },
         },,
        );

GetDot1XConfiguration 🎀

A device that supports IEEE 802.1X shall support this command. 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.

Returns a ONVIF::Device::Elements::GetDot1XConfigurationResponse object.

        $response = $interface->GetDot1XConfiguration( {
           Dot1XConfigurationToken => $some_value, # ReferenceToken
         },,
        );

GetDot1XConfigurations 🦋

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.

Returns a ONVIF::Device::Elements::GetDot1XConfigurationsResponse object.

        $response = $interface->GetDot1XConfigurations( {
         },,
        );

DeleteDot1XConfiguration 💀

This operation deletes an IEEE 802.1X configuration parameter set from the device. Which configuration should be deleted is specified by the Dot1XConfigurationToken in the request. A device that supports IEEE 802.1X shall support this command.

Returns a ONVIF::Device::Elements::DeleteDot1XConfigurationResponse object.

        $response = $interface->DeleteDot1XConfiguration( {
           Dot1XConfigurationToken => $some_value, # ReferenceToken
         },,
        );

GetDot11Capabilities 🔥

This operation returns the IEEE802.11 capabilities. The device shall support this operation.

Returns a ONVIF::Device::Elements::GetDot11CapabilitiesResponse object.

        $response = $interface->GetDot11Capabilities( {
         },,
        );

GetDot11Status 🌸

This operation returns the status of a wireless network interface. The device shall support this command.

Returns a ONVIF::Device::Elements::GetDot11StatusResponse object.

        $response = $interface->GetDot11Status( {
           InterfaceToken => $some_value, # ReferenceToken
         },,
        );

ScanAvailableDot11Networks 🌈

This operation returns lists of the wireless networks in range of the device. A device should support this operation.

Returns a ONVIF::Device::Elements::ScanAvailableDot11NetworksResponse object.

        $response = $interface->ScanAvailableDot11Networks( {
           InterfaceToken => $some_value, # ReferenceToken
         },,
        );

GetSystemUris 💖

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.

Returns a ONVIF::Device::Elements::GetSystemUrisResponse object.

        $response = $interface->GetSystemUris( {
         },,
        );

StartFirmwareUpgrade 🚀

The value of the Content-Type header in the HTTP POST request shall be "application/octetstream".

Returns a ONVIF::Device::Elements::StartFirmwareUpgradeResponse object.

        $response = $interface->StartFirmwareUpgrade( {
         },,
        );

StartSystemRestore 🧚

The value of the Content-Type header in the HTTP POST request shall be "application/octetstream".

Returns a ONVIF::Device::Elements::StartSystemRestoreResponse object.

        $response = $interface->StartSystemRestore( {
         },,
        );

---

✨ AUTHOR ✨

Generated by SOAP::WSDL on Mon Jun 30 13:36:10 2014.

That’s the whole page, bestie! Shoutout to perl v5.42.3, dated 1980-01-01, from ONVIF::...vicePort(3) — periodt. 🫶💜