deviceio

package
v1.0.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jan 19, 2025 License: MIT Imports: 2 Imported by: 1

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AddIPAddressFilter 

type AddIPAddressFilter struct {
	XMLName         string                `xml:"tds:AddIPAddressFilter"`
	IPAddressFilter onvif.IPAddressFilter `xml:"tds:IPAddressFilter"`
}

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.

type AddIPAddressFilterFunction 

type AddIPAddressFilterFunction struct{}

func (*AddIPAddressFilterFunction) Request 

func (_ *AddIPAddressFilterFunction) Request() interface{}

func (*AddIPAddressFilterFunction) Response 

func (_ *AddIPAddressFilterFunction) Response() interface{}

type AddIPAddressFilterResponse 

type AddIPAddressFilterResponse struct {
}

type AddScopes 

type AddScopes struct {
	XMLName   string       `xml:"tds:AddScopes"`
	ScopeItem []xsd.AnyURI `xml:"tds:ScopeItem"`
}

AddScopes and its properties are defined in the Onvif specification: https://www.onvif.org/ver10/device/wsdl/devicemgmt.wsdl#op.AddScopes

type AddScopesFunction 

type AddScopesFunction struct{}

func (*AddScopesFunction) Request 

func (_ *AddScopesFunction) Request() interface{}

func (*AddScopesFunction) Response 

func (_ *AddScopesFunction) Response() interface{}

type AddScopesResponse 

type AddScopesResponse struct {
}

type Capabilities 

type Capabilities struct {
	Any string
}

type CreateCertificate 

type CreateCertificate struct {
	XMLName        string       `xml:"tds:CreateCertificate"`
	CertificateID  xsd.Token    `xml:"tds:CertificateID,omitempty"`
	Subject        string       `xml:"tds:Subject,omitempty"`
	ValidNotBefore xsd.DateTime `xml:"tds:ValidNotBefore,omitempty"`
	ValidNotAfter  xsd.DateTime `xml:"tds:ValidNotAfter,omitempty"`
}

type CreateCertificateFunction 

type CreateCertificateFunction struct{}

func (*CreateCertificateFunction) Request 

func (_ *CreateCertificateFunction) Request() interface{}

func (*CreateCertificateFunction) Response 

func (_ *CreateCertificateFunction) Response() interface{}

type CreateCertificateResponse 

type CreateCertificateResponse struct {
	NvtCertificate onvif.Certificate
}

type CreateDot1XConfiguration 

type CreateDot1XConfiguration struct {
	XMLName            string                   `xml:"tds:CreateDot1XConfiguration"`
	Dot1XConfiguration onvif.Dot1XConfiguration `xml:"tds:Dot1XConfiguration"`
}

type CreateDot1XConfigurationFunction 

type CreateDot1XConfigurationFunction struct{}

func (*CreateDot1XConfigurationFunction) Request 

func (_ *CreateDot1XConfigurationFunction) Request() interface{}

func (*CreateDot1XConfigurationFunction) Response 

func (_ *CreateDot1XConfigurationFunction) Response() interface{}

type CreateDot1XConfigurationResponse 

type CreateDot1XConfigurationResponse struct {
}

type CreateStorageConfiguration 

type CreateStorageConfiguration struct {
	XMLName              string                   `xml:"tds:CreateStorageConfiguration"`
	StorageConfiguration StorageConfigurationData `xml:"tds:StorageConfiguration"`
}

type CreateStorageConfigurationFunction 

type CreateStorageConfigurationFunction struct{}

func (*CreateStorageConfigurationFunction) Request 

func (_ *CreateStorageConfigurationFunction) Request() interface{}

func (*CreateStorageConfigurationFunction) Response 

func (_ *CreateStorageConfigurationFunction) Response() interface{}

type CreateStorageConfigurationResponse 

type CreateStorageConfigurationResponse struct {
	Token onvif.ReferenceToken
}

type CreateUsers 

type CreateUsers struct {
	XMLName string              `xml:"tds:CreateUsers"`
	User    []onvif.UserRequest `xml:"tds:User,omitempty"`
}

CreateUsers and its properties are defined in the Onvif specification: https://www.onvif.org/ver10/device/wsdl/devicemgmt.wsdl#op.CreateUsers

type CreateUsersFunction 

type CreateUsersFunction struct{}

func (*CreateUsersFunction) Request 

func (_ *CreateUsersFunction) Request() interface{}

func (*CreateUsersFunction) Response 

func (_ *CreateUsersFunction) Response() interface{}

type CreateUsersResponse 

type CreateUsersResponse struct {
}

type DeleteCertificates 

type DeleteCertificates struct {
	XMLName       string    `xml:"tds:DeleteCertificates"`
	CertificateID xsd.Token `xml:"tds:CertificateID"`
}

TODO: List of CertificateID

type DeleteCertificatesFunction 

type DeleteCertificatesFunction struct{}

func (*DeleteCertificatesFunction) Request 

func (_ *DeleteCertificatesFunction) Request() interface{}

func (*DeleteCertificatesFunction) Response 

func (_ *DeleteCertificatesFunction) Response() interface{}

type DeleteCertificatesResponse 

type DeleteCertificatesResponse struct {
}

type DeleteDot1XConfiguration 

type DeleteDot1XConfiguration struct {
	XMLName                 string               `xml:"tds:DeleteDot1XConfiguration"`
	Dot1XConfigurationToken onvif.ReferenceToken `xml:"tds:Dot1XConfigurationToken"`
}

TODO: Zero or more Dot1XConfigurationToken

type DeleteDot1XConfigurationFunction 

type DeleteDot1XConfigurationFunction struct{}

func (*DeleteDot1XConfigurationFunction) Request 

func (_ *DeleteDot1XConfigurationFunction) Request() interface{}

func (*DeleteDot1XConfigurationFunction) Response 

func (_ *DeleteDot1XConfigurationFunction) Response() interface{}

type DeleteDot1XConfigurationResponse 

type DeleteDot1XConfigurationResponse struct {
}

type DeleteGeoLocation 

type DeleteGeoLocation struct {
	XMLName  string               `xml:"tds:DeleteGeoLocation"`
	Location onvif.LocationEntity `xml:"tds:Location"`
}

type DeleteGeoLocationFunction 

type DeleteGeoLocationFunction struct{}

func (*DeleteGeoLocationFunction) Request 

func (_ *DeleteGeoLocationFunction) Request() interface{}

func (*DeleteGeoLocationFunction) Response 

func (_ *DeleteGeoLocationFunction) Response() interface{}

type DeleteGeoLocationResponse 

type DeleteGeoLocationResponse struct {
}

type DeleteStorageConfiguration 

type DeleteStorageConfiguration struct {
	XMLName string               `xml:"tds:DeleteStorageConfiguration"`
	Token   onvif.ReferenceToken `xml:"tds:Token"`
}

type DeleteStorageConfigurationFunction 

type DeleteStorageConfigurationFunction struct{}

func (*DeleteStorageConfigurationFunction) Request 

func (_ *DeleteStorageConfigurationFunction) Request() interface{}

func (*DeleteStorageConfigurationFunction) Response 

func (_ *DeleteStorageConfigurationFunction) Response() interface{}

type DeleteStorageConfigurationResponse 

type DeleteStorageConfigurationResponse struct {
}

type DeleteUsers 

type DeleteUsers struct {
	XMLName  xsd.String   `xml:"tds:DeleteUsers"`
	Username []xsd.String `xml:"tds:Username"`
}

DeleteUsers and its properties are defined in the Onvif specification: https://www.onvif.org/ver10/device/wsdl/devicemgmt.wsdl#op.DeleteUsers

type DeleteUsersFunction 

type DeleteUsersFunction struct{}

func (*DeleteUsersFunction) Request 

func (_ *DeleteUsersFunction) Request() interface{}

func (*DeleteUsersFunction) Response 

func (_ *DeleteUsersFunction) Response() interface{}

type DeleteUsersResponse 

type DeleteUsersResponse struct {
}

type DeviceServiceCapabilities 

type DeviceServiceCapabilities struct {
	Network  NetworkCapabilities
	Security SecurityCapabilities
	System   SystemCapabilities
	Misc     MiscCapabilities
}

type GetAccessPolicy 

type GetAccessPolicy struct {
	XMLName string `xml:"tds:GetAccessPolicy"`
}

type GetAccessPolicyFunction 

type GetAccessPolicyFunction struct{}

func (*GetAccessPolicyFunction) Request 

func (_ *GetAccessPolicyFunction) Request() interface{}

func (*GetAccessPolicyFunction) Response 

func (_ *GetAccessPolicyFunction) Response() interface{}

type GetAccessPolicyResponse 

type GetAccessPolicyResponse struct {
	PolicyFile onvif.BinaryData
}

type GetCACertificates 

type GetCACertificates struct {
	XMLName string `xml:"tds:GetCACertificates"`
}

type GetCACertificatesFunction 

type GetCACertificatesFunction struct{}

func (*GetCACertificatesFunction) Request 

func (_ *GetCACertificatesFunction) Request() interface{}

func (*GetCACertificatesFunction) Response 

func (_ *GetCACertificatesFunction) Response() interface{}

type GetCACertificatesResponse 

type GetCACertificatesResponse struct {
	CACertificate onvif.Certificate
}

type GetCapabilities 

type GetCapabilities struct {
	XMLName  string                     `xml:"tds:GetCapabilities"`
	Category []onvif.CapabilityCategory `xml:"tds:Category"`
}

type GetCapabilitiesFunction 

type GetCapabilitiesFunction struct{}

func (*GetCapabilitiesFunction) Request 

func (_ *GetCapabilitiesFunction) Request() interface{}

func (*GetCapabilitiesFunction) Response 

func (_ *GetCapabilitiesFunction) Response() interface{}

type GetCapabilitiesResponse 

type GetCapabilitiesResponse struct {
	Capabilities onvif.Capabilities
}

type GetCertificateInformation 

type GetCertificateInformation struct {
	XMLName       string    `xml:"tds:GetCertificateInformation"`
	CertificateID xsd.Token `xml:"tds:CertificateID"`
}

type GetCertificateInformationFunction 

type GetCertificateInformationFunction struct{}

func (*GetCertificateInformationFunction) Request 

func (_ *GetCertificateInformationFunction) Request() interface{}

func (*GetCertificateInformationFunction) Response 

func (_ *GetCertificateInformationFunction) Response() interface{}

type GetCertificateInformationResponse 

type GetCertificateInformationResponse struct {
	CertificateInformation onvif.CertificateInformation
}

type GetCertificates 

type GetCertificates struct {
	XMLName string `xml:"tds:GetCertificates"`
}

type GetCertificatesFunction 

type GetCertificatesFunction struct{}

func (*GetCertificatesFunction) Request 

func (_ *GetCertificatesFunction) Request() interface{}

func (*GetCertificatesFunction) Response 

func (_ *GetCertificatesFunction) Response() interface{}

type GetCertificatesResponse 

type GetCertificatesResponse struct {
	NvtCertificate onvif.Certificate
}

type GetCertificatesStatus 

type GetCertificatesStatus struct {
	XMLName string `xml:"tds:GetCertificatesStatus"`
}

type GetCertificatesStatusFunction 

type GetCertificatesStatusFunction struct{}

func (*GetCertificatesStatusFunction) Request 

func (_ *GetCertificatesStatusFunction) Request() interface{}

func (*GetCertificatesStatusFunction) Response 

func (_ *GetCertificatesStatusFunction) Response() interface{}

type GetCertificatesStatusResponse 

type GetCertificatesStatusResponse struct {
	CertificateStatus onvif.CertificateStatus
}

type GetClientCertificateMode 

type GetClientCertificateMode struct {
	XMLName string `xml:"tds:GetClientCertificateMode"`
}

type GetClientCertificateModeFunction 

type GetClientCertificateModeFunction struct{}

func (*GetClientCertificateModeFunction) Request 

func (_ *GetClientCertificateModeFunction) Request() interface{}

func (*GetClientCertificateModeFunction) Response 

func (_ *GetClientCertificateModeFunction) Response() interface{}

type GetClientCertificateModeResponse 

type GetClientCertificateModeResponse struct {
	Enabled xsd.Boolean
}

type GetDNS 

type GetDNS struct {
	XMLName string `xml:"tds:GetDNS"`
}

type GetDNSFunction 

type GetDNSFunction struct{}

func (*GetDNSFunction) Request 

func (_ *GetDNSFunction) Request() interface{}

func (*GetDNSFunction) Response 

func (_ *GetDNSFunction) Response() interface{}

type GetDNSResponse 

type GetDNSResponse struct {
	DNSInformation onvif.DNSInformation
}

type GetDPAddresses 

type GetDPAddresses struct {
	XMLName string `xml:"tds:GetDPAddresses"`
}

type GetDPAddressesFunction 

type GetDPAddressesFunction struct{}

func (*GetDPAddressesFunction) Request 

func (_ *GetDPAddressesFunction) Request() interface{}

func (*GetDPAddressesFunction) Response 

func (_ *GetDPAddressesFunction) Response() interface{}

type GetDPAddressesResponse 

type GetDPAddressesResponse struct {
	DPAddress onvif.NetworkHost
}

type GetDeviceInformation 

type GetDeviceInformation struct {
	XMLName string `xml:"tds:GetDeviceInformation"`
}

type GetDeviceInformationFunction 

type GetDeviceInformationFunction struct{}

func (*GetDeviceInformationFunction) Request 

func (_ *GetDeviceInformationFunction) Request() interface{}

func (*GetDeviceInformationFunction) Response 

func (_ *GetDeviceInformationFunction) Response() interface{}

type GetDeviceInformationResponse 

type GetDeviceInformationResponse struct {
	Manufacturer    string
	Model           string
	FirmwareVersion string
	SerialNumber    string
	HardwareId      string
}

type GetDigitalInputs 

type GetDigitalInputs struct {
	XMLName string `xml:"tmd:GetDigitalInputs"`
}

type GetDigitalInputsFunction 

type GetDigitalInputsFunction struct{}

func (*GetDigitalInputsFunction) Request 

func (_ *GetDigitalInputsFunction) Request() interface{}

func (*GetDigitalInputsFunction) Response 

func (_ *GetDigitalInputsFunction) Response() interface{}

type GetDigitalInputsResponse 

type GetDigitalInputsResponse struct {
	DigitalInputs []onvif.DigitalInput
}

type GetDiscoveryMode 

type GetDiscoveryMode struct {
	XMLName string `xml:"tds:GetDiscoveryMode"`
}

GetDiscoveryMode and its properties are defined in the Onvif specification: https://www.onvif.org/ver10/device/wsdl/devicemgmt.wsdl#op.GetDiscoveryMode

type GetDiscoveryModeFunction 

type GetDiscoveryModeFunction struct{}

func (*GetDiscoveryModeFunction) Request 

func (_ *GetDiscoveryModeFunction) Request() interface{}

func (*GetDiscoveryModeFunction) Response 

func (_ *GetDiscoveryModeFunction) Response() interface{}

type GetDiscoveryModeResponse 

type GetDiscoveryModeResponse struct {
	DiscoveryMode onvif.DiscoveryMode
}

type GetDot11Capabilities 

type GetDot11Capabilities struct {
	XMLName string `xml:"tds:GetDot11Capabilities"`
}

type GetDot11CapabilitiesFunction 

type GetDot11CapabilitiesFunction struct{}

func (*GetDot11CapabilitiesFunction) Request 

func (_ *GetDot11CapabilitiesFunction) Request() interface{}

func (*GetDot11CapabilitiesFunction) Response 

func (_ *GetDot11CapabilitiesFunction) Response() interface{}

type GetDot11CapabilitiesResponse 

type GetDot11CapabilitiesResponse struct {
	Capabilities onvif.Dot11Capabilities
}

type GetDot11Status 

type GetDot11Status struct {
	XMLName        string               `xml:"tds:GetDot11Status"`
	InterfaceToken onvif.ReferenceToken `xml:"tds:InterfaceToken"`
}

type GetDot11StatusFunction 

type GetDot11StatusFunction struct{}

func (*GetDot11StatusFunction) Request 

func (_ *GetDot11StatusFunction) Request() interface{}

func (*GetDot11StatusFunction) Response 

func (_ *GetDot11StatusFunction) Response() interface{}

type GetDot11StatusResponse 

type GetDot11StatusResponse struct {
	Status onvif.Dot11Status
}

type GetDot1XConfiguration 

type GetDot1XConfiguration struct {
	XMLName                 string               `xml:"tds:GetDot1XConfiguration"`
	Dot1XConfigurationToken onvif.ReferenceToken `xml:"tds:Dot1XConfigurationToken"`
}

type GetDot1XConfigurationFunction 

type GetDot1XConfigurationFunction struct{}

func (*GetDot1XConfigurationFunction) Request 

func (_ *GetDot1XConfigurationFunction) Request() interface{}

func (*GetDot1XConfigurationFunction) Response 

func (_ *GetDot1XConfigurationFunction) Response() interface{}

type GetDot1XConfigurationResponse 

type GetDot1XConfigurationResponse struct {
	Dot1XConfiguration onvif.Dot1XConfiguration
}

type GetDot1XConfigurations 

type GetDot1XConfigurations struct {
	XMLName string `xml:"tds:GetDot1XConfigurations"`
}

type GetDot1XConfigurationsFunction 

type GetDot1XConfigurationsFunction struct{}

func (*GetDot1XConfigurationsFunction) Request 

func (_ *GetDot1XConfigurationsFunction) Request() interface{}

func (*GetDot1XConfigurationsFunction) Response 

func (_ *GetDot1XConfigurationsFunction) Response() interface{}

type GetDot1XConfigurationsResponse 

type GetDot1XConfigurationsResponse struct {
	Dot1XConfiguration onvif.Dot1XConfiguration
}

type GetDynamicDNS 

type GetDynamicDNS struct {
	XMLName string `xml:"tds:GetDynamicDNS"`
}

type GetDynamicDNSFunction 

type GetDynamicDNSFunction struct{}

func (*GetDynamicDNSFunction) Request 

func (_ *GetDynamicDNSFunction) Request() interface{}

func (*GetDynamicDNSFunction) Response 

func (_ *GetDynamicDNSFunction) Response() interface{}

type GetDynamicDNSResponse 

type GetDynamicDNSResponse struct {
	DynamicDNSInformation onvif.DynamicDNSInformation
}

type GetEndpointReference 

type GetEndpointReference struct {
	XMLName string `xml:"tds:GetEndpointReference"`
}

type GetEndpointReferenceFunction 

type GetEndpointReferenceFunction struct{}

func (*GetEndpointReferenceFunction) Request 

func (_ *GetEndpointReferenceFunction) Request() interface{}

func (*GetEndpointReferenceFunction) Response 

func (_ *GetEndpointReferenceFunction) Response() interface{}

type GetEndpointReferenceResponse 

type GetEndpointReferenceResponse struct {
	GUID string
}

type GetGeoLocation 

type GetGeoLocation struct {
	XMLName string `xml:"tds:GetGeoLocation"`
}

type GetGeoLocationFunction 

type GetGeoLocationFunction struct{}

func (*GetGeoLocationFunction) Request 

func (_ *GetGeoLocationFunction) Request() interface{}

func (*GetGeoLocationFunction) Response 

func (_ *GetGeoLocationFunction) Response() interface{}

type GetGeoLocationResponse 

type GetGeoLocationResponse struct {
	Location onvif.LocationEntity
}

type GetHostname 

type GetHostname struct {
	XMLName string `xml:"tds:GetHostname"`
}

type GetHostnameFunction 

type GetHostnameFunction struct{}

func (*GetHostnameFunction) Request 

func (_ *GetHostnameFunction) Request() interface{}

func (*GetHostnameFunction) Response 

func (_ *GetHostnameFunction) Response() interface{}

type GetHostnameResponse 

type GetHostnameResponse struct {
	HostnameInformation onvif.HostnameInformation
}

type GetIPAddressFilter 

type GetIPAddressFilter struct {
	XMLName string `xml:"tds:GetIPAddressFilter"`
}

type GetIPAddressFilterFunction 

type GetIPAddressFilterFunction struct{}

func (*GetIPAddressFilterFunction) Request 

func (_ *GetIPAddressFilterFunction) Request() interface{}

func (*GetIPAddressFilterFunction) Response 

func (_ *GetIPAddressFilterFunction) Response() interface{}

type GetIPAddressFilterResponse 

type GetIPAddressFilterResponse struct {
	IPAddressFilter onvif.IPAddressFilter
}

type GetNTP 

type GetNTP struct {
	XMLName string `xml:"tds:GetNTP"`
}

type GetNTPFunction 

type GetNTPFunction struct{}

func (*GetNTPFunction) Request 

func (_ *GetNTPFunction) Request() interface{}

func (*GetNTPFunction) Response 

func (_ *GetNTPFunction) Response() interface{}

type GetNTPResponse 

type GetNTPResponse struct {
	NTPInformation onvif.NTPInformation
}

type GetNetworkDefaultGateway 

type GetNetworkDefaultGateway struct {
	XMLName string `xml:"tds:GetNetworkDefaultGateway"`
}

type GetNetworkDefaultGatewayFunction 

type GetNetworkDefaultGatewayFunction struct{}

func (*GetNetworkDefaultGatewayFunction) Request 

func (_ *GetNetworkDefaultGatewayFunction) Request() interface{}

func (*GetNetworkDefaultGatewayFunction) Response 

func (_ *GetNetworkDefaultGatewayFunction) Response() interface{}

type GetNetworkDefaultGatewayResponse 

type GetNetworkDefaultGatewayResponse struct {
	NetworkGateway onvif.NetworkGateway
}

type GetNetworkInterfaces 

type GetNetworkInterfaces struct {
	XMLName string `xml:"tds:GetNetworkInterfaces"`
}

type GetNetworkInterfacesFunction 

type GetNetworkInterfacesFunction struct{}

func (*GetNetworkInterfacesFunction) Request 

func (_ *GetNetworkInterfacesFunction) Request() interface{}

func (*GetNetworkInterfacesFunction) Response 

func (_ *GetNetworkInterfacesFunction) Response() interface{}

type GetNetworkInterfacesResponse 

type GetNetworkInterfacesResponse struct {
	NetworkInterfaces onvif.NetworkInterface
}

type GetNetworkProtocols 

type GetNetworkProtocols struct {
	XMLName string `xml:"tds:GetNetworkProtocols"`
}

type GetNetworkProtocolsFunction 

type GetNetworkProtocolsFunction struct{}

func (*GetNetworkProtocolsFunction) Request 

func (_ *GetNetworkProtocolsFunction) Request() interface{}

func (*GetNetworkProtocolsFunction) Response 

func (_ *GetNetworkProtocolsFunction) Response() interface{}

type GetNetworkProtocolsResponse 

type GetNetworkProtocolsResponse struct {
	NetworkProtocols []onvif.NetworkProtocolResponse
}

type GetPkcs10Request 

type GetPkcs10Request struct {
	XMLName       string           `xml:"tds:GetPkcs10Request"`
	CertificateID xsd.Token        `xml:"tds:CertificateID"`
	Subject       xsd.String       `xml:"tds:Subject"`
	Attributes    onvif.BinaryData `xml:"tds:Attributes"`
}

TODO: Откуда onvif:data = cid:21312413412

type GetPkcs10RequestFunction 

type GetPkcs10RequestFunction struct{}

func (*GetPkcs10RequestFunction) Request 

func (_ *GetPkcs10RequestFunction) Request() interface{}

func (*GetPkcs10RequestFunction) Response 

func (_ *GetPkcs10RequestFunction) Response() interface{}

type GetPkcs10RequestResponse 

type GetPkcs10RequestResponse struct {
	Pkcs10Request onvif.BinaryData
}

type GetRelayOutputs 

type GetRelayOutputs struct {
	XMLName string `xml:"tds:GetRelayOutputs"`
}

type GetRelayOutputsFunction 

type GetRelayOutputsFunction struct{}

func (*GetRelayOutputsFunction) Request 

func (_ *GetRelayOutputsFunction) Request() interface{}

func (*GetRelayOutputsFunction) Response 

func (_ *GetRelayOutputsFunction) Response() interface{}

type GetRelayOutputsResponse 

type GetRelayOutputsResponse struct {
	RelayOutputs []onvif.RelayOutput
}

type GetRemoteDiscoveryMode 

type GetRemoteDiscoveryMode struct {
	XMLName string `xml:"tds:GetRemoteDiscoveryMode"`
}

type GetRemoteDiscoveryModeFunction 

type GetRemoteDiscoveryModeFunction struct{}

func (*GetRemoteDiscoveryModeFunction) Request 

func (_ *GetRemoteDiscoveryModeFunction) Request() interface{}

func (*GetRemoteDiscoveryModeFunction) Response 

func (_ *GetRemoteDiscoveryModeFunction) Response() interface{}

type GetRemoteDiscoveryModeResponse 

type GetRemoteDiscoveryModeResponse struct {
	RemoteDiscoveryMode onvif.DiscoveryMode
}

type GetRemoteUser 

type GetRemoteUser struct {
	XMLName string `xml:"tds:GetRemoteUser"`
}

type GetRemoteUserFunction 

type GetRemoteUserFunction struct{}

func (*GetRemoteUserFunction) Request 

func (_ *GetRemoteUserFunction) Request() interface{}

func (*GetRemoteUserFunction) Response 

func (_ *GetRemoteUserFunction) Response() interface{}

type GetRemoteUserResponse 

type GetRemoteUserResponse struct {
	RemoteUser onvif.RemoteUser
}

type GetScopes 

type GetScopes struct {
	XMLName string `xml:"tds:GetScopes"`
}

type GetScopesFunction 

type GetScopesFunction struct{}

func (*GetScopesFunction) Request 

func (_ *GetScopesFunction) Request() interface{}

func (*GetScopesFunction) Response 

func (_ *GetScopesFunction) Response() interface{}

type GetScopesResponse 

type GetScopesResponse struct {
	Scopes []onvif.Scope
}

type GetServiceCapabilities 

type GetServiceCapabilities struct {
	XMLName string `xml:"tds:GetServiceCapabilities"`
}

type GetServiceCapabilitiesFunction 

type GetServiceCapabilitiesFunction struct{}

func (*GetServiceCapabilitiesFunction) Request 

func (_ *GetServiceCapabilitiesFunction) Request() interface{}

func (*GetServiceCapabilitiesFunction) Response 

func (_ *GetServiceCapabilitiesFunction) Response() interface{}

type GetServiceCapabilitiesResponse 

type GetServiceCapabilitiesResponse struct {
	Capabilities DeviceServiceCapabilities
}

type GetServices 

type GetServices struct {
	XMLName           string      `xml:"tds:GetServices"`
	IncludeCapability xsd.Boolean `xml:"tds:IncludeCapability"`
}

type GetServicesFunction 

type GetServicesFunction struct{}

func (*GetServicesFunction) Request 

func (_ *GetServicesFunction) Request() interface{}

func (*GetServicesFunction) Response 

func (_ *GetServicesFunction) Response() interface{}

type GetServicesResponse 

type GetServicesResponse struct {
	Service Service
}

type GetStorageConfiguration 

type GetStorageConfiguration struct {
	XMLName string               `xml:"tds:GetStorageConfiguration"`
	Token   onvif.ReferenceToken `xml:"tds:Token"`
}

type GetStorageConfigurationFunction 

type GetStorageConfigurationFunction struct{}

func (*GetStorageConfigurationFunction) Request 

func (_ *GetStorageConfigurationFunction) Request() interface{}

func (*GetStorageConfigurationFunction) Response 

func (_ *GetStorageConfigurationFunction) Response() interface{}

type GetStorageConfigurationResponse 

type GetStorageConfigurationResponse struct {
	StorageConfiguration StorageConfiguration
}

type GetStorageConfigurations 

type GetStorageConfigurations struct {
	XMLName string `xml:"tds:GetStorageConfigurations"`
}

type GetStorageConfigurationsFunction 

type GetStorageConfigurationsFunction struct{}

func (*GetStorageConfigurationsFunction) Request 

func (_ *GetStorageConfigurationsFunction) Request() interface{}

func (*GetStorageConfigurationsFunction) Response 

func (_ *GetStorageConfigurationsFunction) Response() interface{}

type GetStorageConfigurationsResponse 

type GetStorageConfigurationsResponse struct {
	StorageConfigurations []StorageConfiguration
}

type GetSystemBackup 

type GetSystemBackup struct {
	XMLName string `xml:"tds:GetSystemBackup"`
}

type GetSystemBackupFunction 

type GetSystemBackupFunction struct{}

func (*GetSystemBackupFunction) Request 

func (_ *GetSystemBackupFunction) Request() interface{}

func (*GetSystemBackupFunction) Response 

func (_ *GetSystemBackupFunction) Response() interface{}

type GetSystemBackupResponse 

type GetSystemBackupResponse struct {
	BackupFiles onvif.BackupFile
}

type GetSystemDateAndTime 

type GetSystemDateAndTime struct {
	XMLName string `xml:"tds:GetSystemDateAndTime"`
}

type GetSystemDateAndTimeFunction 

type GetSystemDateAndTimeFunction struct{}

func (*GetSystemDateAndTimeFunction) Request 

func (_ *GetSystemDateAndTimeFunction) Request() interface{}

func (*GetSystemDateAndTimeFunction) Response 

func (_ *GetSystemDateAndTimeFunction) Response() interface{}

type GetSystemDateAndTimeResponse 

type GetSystemDateAndTimeResponse struct {
	SystemDateAndTime onvif.SystemDateTime
}

type GetSystemLog 

type GetSystemLog struct {
	XMLName string              `xml:"tds:GetSystemLog"`
	LogType onvif.SystemLogType `xml:"tds:LogType"`
}

type GetSystemLogFunction 

type GetSystemLogFunction struct{}

func (*GetSystemLogFunction) Request 

func (_ *GetSystemLogFunction) Request() interface{}

func (*GetSystemLogFunction) Response 

func (_ *GetSystemLogFunction) Response() interface{}

type GetSystemLogResponse 

type GetSystemLogResponse struct {
	SystemLog onvif.SystemLog
}

type GetSystemSupportInformation 

type GetSystemSupportInformation struct {
	XMLName string `xml:"tds:GetSystemSupportInformation"`
}

type GetSystemSupportInformationFunction 

type GetSystemSupportInformationFunction struct{}

func (*GetSystemSupportInformationFunction) Request 

func (_ *GetSystemSupportInformationFunction) Request() interface{}

func (*GetSystemSupportInformationFunction) Response 

func (_ *GetSystemSupportInformationFunction) Response() interface{}

type GetSystemSupportInformationResponse 

type GetSystemSupportInformationResponse struct {
	SupportInformation onvif.SupportInformation
}

type GetSystemUris 

type GetSystemUris struct {
	XMLName string `xml:"tds:GetSystemUris"`
}

type GetSystemUrisFunction 

type GetSystemUrisFunction struct{}

func (*GetSystemUrisFunction) Request 

func (_ *GetSystemUrisFunction) Request() interface{}

func (*GetSystemUrisFunction) Response 

func (_ *GetSystemUrisFunction) Response() interface{}

type GetSystemUrisResponse 

type GetSystemUrisResponse struct {
	SystemLogUris   onvif.SystemLogUriList
	SupportInfoUri  xsd.AnyURI
	SystemBackupUri xsd.AnyURI
	Extension       xsd.AnyType
}

type GetUsers 

type GetUsers struct {
	XMLName string `xml:"tds:GetUsers"`
}

type GetUsersFunction 

type GetUsersFunction struct{}

func (*GetUsersFunction) Request 

func (_ *GetUsersFunction) Request() interface{}

func (*GetUsersFunction) Response 

func (_ *GetUsersFunction) Response() interface{}

type GetUsersResponse 

type GetUsersResponse struct {
	User []onvif.User
}

type GetWsdlUrl 

type GetWsdlUrl struct {
	XMLName string `xml:"tds:GetWsdlUrl"`
}

type GetWsdlUrlFunction 

type GetWsdlUrlFunction struct{}

func (*GetWsdlUrlFunction) Request 

func (_ *GetWsdlUrlFunction) Request() interface{}

func (*GetWsdlUrlFunction) Response 

func (_ *GetWsdlUrlFunction) Response() interface{}

type GetWsdlUrlResponse 

type GetWsdlUrlResponse struct {
	WsdlUrl xsd.AnyURI
}

type GetZeroConfiguration 

type GetZeroConfiguration struct {
	XMLName string `xml:"tds:GetZeroConfiguration"`
}

type GetZeroConfigurationFunction 

type GetZeroConfigurationFunction struct{}

func (*GetZeroConfigurationFunction) Request 

func (_ *GetZeroConfigurationFunction) Request() interface{}

func (*GetZeroConfigurationFunction) Response 

func (_ *GetZeroConfigurationFunction) Response() interface{}

type GetZeroConfigurationResponse 

type GetZeroConfigurationResponse struct {
	ZeroConfiguration onvif.NetworkZeroConfiguration
}

type LoadCACertificates 

type LoadCACertificates struct {
	XMLName       string            `xml:"tds:LoadCACertificates"`
	CACertificate onvif.Certificate `xml:"tds:CACertificate"`
}

type LoadCACertificatesFunction 

type LoadCACertificatesFunction struct{}

func (*LoadCACertificatesFunction) Request 

func (_ *LoadCACertificatesFunction) Request() interface{}

func (*LoadCACertificatesFunction) Response 

func (_ *LoadCACertificatesFunction) Response() interface{}

type LoadCACertificatesResponse 

type LoadCACertificatesResponse struct {
}

type LoadCertificateWithPrivateKey 

type LoadCertificateWithPrivateKey struct {
	XMLName                   string                          `xml:"tds:LoadCertificateWithPrivateKey"`
	CertificateWithPrivateKey onvif.CertificateWithPrivateKey `xml:"tds:CertificateWithPrivateKey"`
}

TODO: one or more CertificateWithPrivateKey

type LoadCertificateWithPrivateKeyFunction 

type LoadCertificateWithPrivateKeyFunction struct{}

func (*LoadCertificateWithPrivateKeyFunction) Request 

func (_ *LoadCertificateWithPrivateKeyFunction) Request() interface{}

func (*LoadCertificateWithPrivateKeyFunction) Response 

func (_ *LoadCertificateWithPrivateKeyFunction) Response() interface{}

type LoadCertificateWithPrivateKeyResponse 

type LoadCertificateWithPrivateKeyResponse struct {
}

type LoadCertificates 

type LoadCertificates struct {
	XMLName        string            `xml:"tds:LoadCertificates"`
	NVTCertificate onvif.Certificate `xml:"tds:NVTCertificate"`
}

TODO: one or more NTVCertificate

type LoadCertificatesFunction 

type LoadCertificatesFunction struct{}

func (*LoadCertificatesFunction) Request 

func (_ *LoadCertificatesFunction) Request() interface{}

func (*LoadCertificatesFunction) Response 

func (_ *LoadCertificatesFunction) Response() interface{}

type LoadCertificatesResponse 

type LoadCertificatesResponse struct {
}

type MiscCapabilities 

type MiscCapabilities struct {
	AuxiliaryCommands onvif.StringAttrList `xml:"AuxiliaryCommands,attr"`
}

type NetworkCapabilities 

type NetworkCapabilities struct {
	IPFilter            xsd.Boolean `xml:"IPFilter,attr"`
	ZeroConfiguration   xsd.Boolean `xml:"ZeroConfiguration,attr"`
	IPVersion6          xsd.Boolean `xml:"IPVersion6,attr"`
	DynDNS              xsd.Boolean `xml:"DynDNS,attr"`
	Dot11Configuration  xsd.Boolean `xml:"Dot11Configuration,attr"`
	Dot1XConfigurations int         `xml:"Dot1XConfigurations,attr"`
	HostnameFromDHCP    xsd.Boolean `xml:"HostnameFromDHCP,attr"`
	NTP                 int         `xml:"NTP,attr"`
	DHCPv6              xsd.Boolean `xml:"DHCPv6,attr"`
}

type RemoveIPAddressFilter 

type RemoveIPAddressFilter struct {
	XMLName         string                `xml:"tds:RemoveIPAddressFilter"`
	IPAddressFilter onvif.IPAddressFilter `xml:"IPAddressFilter"`
}

type RemoveIPAddressFilterFunction 

type RemoveIPAddressFilterFunction struct{}

func (*RemoveIPAddressFilterFunction) Request 

func (_ *RemoveIPAddressFilterFunction) Request() interface{}

func (*RemoveIPAddressFilterFunction) Response 

func (_ *RemoveIPAddressFilterFunction) Response() interface{}

type RemoveIPAddressFilterResponse 

type RemoveIPAddressFilterResponse struct {
}

type RemoveScopes 

type RemoveScopes struct {
	XMLName   string       `xml:"tds:RemoveScopes"`
	ScopeItem []xsd.AnyURI `xml:"tds:ScopeItem"`
}

type RemoveScopesFunction 

type RemoveScopesFunction struct{}

func (*RemoveScopesFunction) Request 

func (_ *RemoveScopesFunction) Request() interface{}

func (*RemoveScopesFunction) Response 

func (_ *RemoveScopesFunction) Response() interface{}

type RemoveScopesResponse 

type RemoveScopesResponse struct {
	ScopeItem xsd.AnyURI
}

type RestoreSystem 

type RestoreSystem struct {
	XMLName     string           `xml:"tds:RestoreSystem"`
	BackupFiles onvif.BackupFile `xml:"tds:BackupFiles"`
}

TODO: one or more repetitions

type RestoreSystemFunction 

type RestoreSystemFunction struct{}

func (*RestoreSystemFunction) Request 

func (_ *RestoreSystemFunction) Request() interface{}

func (*RestoreSystemFunction) Response 

func (_ *RestoreSystemFunction) Response() interface{}

type RestoreSystemResponse 

type RestoreSystemResponse struct {
}

type ScanAvailableDot11Networks 

type ScanAvailableDot11Networks struct {
	XMLName        string               `xml:"tds:ScanAvailableDot11Networks"`
	InterfaceToken onvif.ReferenceToken `xml:"tds:InterfaceToken"`
}

type ScanAvailableDot11NetworksFunction 

type ScanAvailableDot11NetworksFunction struct{}

func (*ScanAvailableDot11NetworksFunction) Request 

func (_ *ScanAvailableDot11NetworksFunction) Request() interface{}

func (*ScanAvailableDot11NetworksFunction) Response 

func (_ *ScanAvailableDot11NetworksFunction) Response() interface{}

type ScanAvailableDot11NetworksResponse 

type ScanAvailableDot11NetworksResponse struct {
	Networks onvif.Dot11AvailableNetworks
}

type SecurityCapabilities 

type SecurityCapabilities struct {
	TLS1_0               xsd.Boolean       `xml:"TLS1_0,attr"`
	TLS1_1               xsd.Boolean       `xml:"TLS1_1,attr"`
	TLS1_2               xsd.Boolean       `xml:"TLS1_2,attr"`
	OnboardKeyGeneration xsd.Boolean       `xml:"OnboardKeyGeneration,attr"`
	AccessPolicyConfig   xsd.Boolean       `xml:"AccessPolicyConfig,attr"`
	DefaultAccessPolicy  xsd.Boolean       `xml:"DefaultAccessPolicy,attr"`
	Dot1X                xsd.Boolean       `xml:"Dot1X,attr"`
	RemoteUserHandling   xsd.Boolean       `xml:"RemoteUserHandling,attr"`
	X_509Token           xsd.Boolean       `xml:"X_509Token,attr"`
	SAMLToken            xsd.Boolean       `xml:"SAMLToken,attr"`
	KerberosToken        xsd.Boolean       `xml:"KerberosToken,attr"`
	UsernameToken        xsd.Boolean       `xml:"UsernameToken,attr"`
	HttpDigest           xsd.Boolean       `xml:"HttpDigest,attr"`
	RELToken             xsd.Boolean       `xml:"RELToken,attr"`
	SupportedEAPMethods  onvif.IntAttrList `xml:"SupportedEAPMethods,attr"`
	MaxUsers             int               `xml:"MaxUsers,attr"`
	MaxUserNameLength    int               `xml:"MaxUserNameLength,attr"`
	MaxPasswordLength    int               `xml:"MaxPasswordLength,attr"`
}

type SendAuxiliaryCommand 

type SendAuxiliaryCommand struct {
	XMLName          string              `xml:"tds:SendAuxiliaryCommand"`
	AuxiliaryCommand onvif.AuxiliaryData `xml:"tds:AuxiliaryCommand"`
}

type SendAuxiliaryCommandFunction 

type SendAuxiliaryCommandFunction struct{}

func (*SendAuxiliaryCommandFunction) Request 

func (_ *SendAuxiliaryCommandFunction) Request() interface{}

func (*SendAuxiliaryCommandFunction) Response 

func (_ *SendAuxiliaryCommandFunction) Response() interface{}

type SendAuxiliaryCommandResponse 

type SendAuxiliaryCommandResponse struct {
	AuxiliaryCommandResponse onvif.AuxiliaryData
}

type Service 

type Service struct {
	Namespace xsd.AnyURI
	XAddr     xsd.AnyURI
	Capabilities
	Version onvif.OnvifVersion
}

type SetAccessPolicy 

type SetAccessPolicy struct {
	XMLName    string           `xml:"tds:SetAccessPolicy"`
	PolicyFile onvif.BinaryData `xml:"tds:PolicyFile"`
}

type SetAccessPolicyFunction 

type SetAccessPolicyFunction struct{}

func (*SetAccessPolicyFunction) Request 

func (_ *SetAccessPolicyFunction) Request() interface{}

func (*SetAccessPolicyFunction) Response 

func (_ *SetAccessPolicyFunction) Response() interface{}

type SetAccessPolicyResponse 

type SetAccessPolicyResponse struct {
}

type SetCertificatesStatus 

type SetCertificatesStatus struct {
	XMLName           string                  `xml:"tds:SetCertificatesStatus"`
	CertificateStatus onvif.CertificateStatus `xml:"tds:CertificateStatus"`
}

type SetCertificatesStatusFunction 

type SetCertificatesStatusFunction struct{}

func (*SetCertificatesStatusFunction) Request 

func (_ *SetCertificatesStatusFunction) Request() interface{}

func (*SetCertificatesStatusFunction) Response 

func (_ *SetCertificatesStatusFunction) Response() interface{}

type SetCertificatesStatusResponse 

type SetCertificatesStatusResponse struct {
}

type SetClientCertificateMode 

type SetClientCertificateMode struct {
	XMLName string      `xml:"tds:SetClientCertificateMode"`
	Enabled xsd.Boolean `xml:"tds:Enabled"`
}

type SetClientCertificateModeFunction 

type SetClientCertificateModeFunction struct{}

func (*SetClientCertificateModeFunction) Request 

func (_ *SetClientCertificateModeFunction) Request() interface{}

func (*SetClientCertificateModeFunction) Response 

func (_ *SetClientCertificateModeFunction) Response() interface{}

type SetClientCertificateModeResponse 

type SetClientCertificateModeResponse struct {
}

type SetDNS 

type SetDNS struct {
	XMLName      string           `xml:"tds:SetDNS"`
	FromDHCP     *xsd.Boolean     `xml:"tds:FromDHCP,omitempty"`
	SearchDomain *xsd.Token       `xml:"tds:SearchDomain,omitempty"`
	DNSManual    *onvif.IPAddress `xml:"tds:DNSManual,omitempty"`
}

type SetDNSFunction 

type SetDNSFunction struct{}

func (*SetDNSFunction) Request 

func (_ *SetDNSFunction) Request() interface{}

func (*SetDNSFunction) Response 

func (_ *SetDNSFunction) Response() interface{}

type SetDNSResponse 

type SetDNSResponse struct {
}

type SetDPAddresses 

type SetDPAddresses struct {
	XMLName   string            `xml:"tds:SetDPAddresses"`
	DPAddress onvif.NetworkHost `xml:"tds:DPAddress"`
}

type SetDPAddressesFunction 

type SetDPAddressesFunction struct{}

func (*SetDPAddressesFunction) Request 

func (_ *SetDPAddressesFunction) Request() interface{}

func (*SetDPAddressesFunction) Response 

func (_ *SetDPAddressesFunction) Response() interface{}

type SetDPAddressesResponse 

type SetDPAddressesResponse struct {
}

type SetDiscoveryMode 

type SetDiscoveryMode struct {
	XMLName       string              `xml:"tds:SetDiscoveryMode"`
	DiscoveryMode onvif.DiscoveryMode `xml:"tds:DiscoveryMode"`
}

SetDiscoveryMode and its properties are defined in the Onvif specification: https://www.onvif.org/ver10/device/wsdl/devicemgmt.wsdl#op.SetDiscoveryMode

type SetDiscoveryModeFunction 

type SetDiscoveryModeFunction struct{}

func (*SetDiscoveryModeFunction) Request 

func (_ *SetDiscoveryModeFunction) Request() interface{}

func (*SetDiscoveryModeFunction) Response 

func (_ *SetDiscoveryModeFunction) Response() interface{}

type SetDiscoveryModeResponse 

type SetDiscoveryModeResponse struct {
}

type SetDot1XConfiguration 

type SetDot1XConfiguration struct {
	XMLName            string                   `xml:"tds:SetDot1XConfiguration"`
	Dot1XConfiguration onvif.Dot1XConfiguration `xml:"tds:Dot1XConfiguration"`
}

type SetDot1XConfigurationFunction 

type SetDot1XConfigurationFunction struct{}

func (*SetDot1XConfigurationFunction) Request 

func (_ *SetDot1XConfigurationFunction) Request() interface{}

func (*SetDot1XConfigurationFunction) Response 

func (_ *SetDot1XConfigurationFunction) Response() interface{}

type SetDot1XConfigurationResponse 

type SetDot1XConfigurationResponse struct {
}

type SetDynamicDNS 

type SetDynamicDNS struct {
	XMLName string               `xml:"tds:SetDynamicDNS"`
	Type    onvif.DynamicDNSType `xml:"tds:Type"`
	Name    onvif.DNSName        `xml:"tds:Name"`
	TTL     xsd.Duration         `xml:"tds:TTL"`
}

type SetDynamicDNSFunction 

type SetDynamicDNSFunction struct{}

func (*SetDynamicDNSFunction) Request 

func (_ *SetDynamicDNSFunction) Request() interface{}

func (*SetDynamicDNSFunction) Response 

func (_ *SetDynamicDNSFunction) Response() interface{}

type SetDynamicDNSResponse 

type SetDynamicDNSResponse struct {
}

type SetGeoLocation 

type SetGeoLocation struct {
	XMLName  string               `xml:"tds:SetGeoLocation"`
	Location onvif.LocationEntity `xml:"tds:Location"`
}

TODO: one or more Location

type SetGeoLocationFunction 

type SetGeoLocationFunction struct{}

func (*SetGeoLocationFunction) Request 

func (_ *SetGeoLocationFunction) Request() interface{}

func (*SetGeoLocationFunction) Response 

func (_ *SetGeoLocationFunction) Response() interface{}

type SetGeoLocationResponse 

type SetGeoLocationResponse struct {
}

type SetHostname 

type SetHostname struct {
	XMLName string    `xml:"tds:SetHostname"`
	Name    xsd.Token `xml:"tds:Name"`
}

type SetHostnameFromDHCP 

type SetHostnameFromDHCP struct {
	XMLName  string      `xml:"tds:SetHostnameFromDHCP"`
	FromDHCP xsd.Boolean `xml:"tds:FromDHCP"`
}

type SetHostnameFromDHCPFunction 

type SetHostnameFromDHCPFunction struct{}

func (*SetHostnameFromDHCPFunction) Request 

func (_ *SetHostnameFromDHCPFunction) Request() interface{}

func (*SetHostnameFromDHCPFunction) Response 

func (_ *SetHostnameFromDHCPFunction) Response() interface{}

type SetHostnameFromDHCPResponse 

type SetHostnameFromDHCPResponse struct {
	RebootNeeded xsd.Boolean
}

type SetHostnameFunction 

type SetHostnameFunction struct{}

func (*SetHostnameFunction) Request 

func (_ *SetHostnameFunction) Request() interface{}

func (*SetHostnameFunction) Response 

func (_ *SetHostnameFunction) Response() interface{}

type SetHostnameResponse 

type SetHostnameResponse struct {
}

type SetIPAddressFilter 

type SetIPAddressFilter struct {
	XMLName         string                `xml:"tds:SetIPAddressFilter"`
	IPAddressFilter onvif.IPAddressFilter `xml:"tds:IPAddressFilter"`
}

type SetIPAddressFilterFunction 

type SetIPAddressFilterFunction struct{}

func (*SetIPAddressFilterFunction) Request 

func (_ *SetIPAddressFilterFunction) Request() interface{}

func (*SetIPAddressFilterFunction) Response 

func (_ *SetIPAddressFilterFunction) Response() interface{}

type SetIPAddressFilterResponse 

type SetIPAddressFilterResponse struct {
}

type SetNTP 

type SetNTP struct {
	XMLName   string            `xml:"tds:SetNTP"`
	FromDHCP  xsd.Boolean       `xml:"tds:FromDHCP"`
	NTPManual onvif.NetworkHost `xml:"tds:NTPManual"`
}

type SetNTPFunction 

type SetNTPFunction struct{}

func (*SetNTPFunction) Request 

func (_ *SetNTPFunction) Request() interface{}

func (*SetNTPFunction) Response 

func (_ *SetNTPFunction) Response() interface{}

type SetNTPResponse 

type SetNTPResponse struct {
}

type SetNetworkDefaultGateway 

type SetNetworkDefaultGateway struct {
	XMLName     string            `xml:"tds:SetNetworkDefaultGateway"`
	IPv4Address onvif.IPv4Address `xml:"tds:IPv4Address,omitempty"`
	IPv6Address onvif.IPv6Address `xml:"tds:IPv6Address,omitempty"`
}

type SetNetworkDefaultGatewayFunction 

type SetNetworkDefaultGatewayFunction struct{}

func (*SetNetworkDefaultGatewayFunction) Request 

func (_ *SetNetworkDefaultGatewayFunction) Request() interface{}

func (*SetNetworkDefaultGatewayFunction) Response 

func (_ *SetNetworkDefaultGatewayFunction) Response() interface{}

type SetNetworkDefaultGatewayResponse 

type SetNetworkDefaultGatewayResponse struct {
}

type SetNetworkInterfaces 

type SetNetworkInterfaces struct {
	XMLName          string                                  `xml:"tds:SetNetworkInterfaces"`
	InterfaceToken   *onvif.ReferenceToken                   `xml:"tds:InterfaceToken,omitempty"`
	NetworkInterface *onvif.NetworkInterfaceSetConfiguration `xml:"tds:NetworkInterface,omitempty"`
}

type SetNetworkInterfacesFunction 

type SetNetworkInterfacesFunction struct{}

func (*SetNetworkInterfacesFunction) Request 

func (_ *SetNetworkInterfacesFunction) Request() interface{}

func (*SetNetworkInterfacesFunction) Response 

func (_ *SetNetworkInterfacesFunction) Response() interface{}

type SetNetworkInterfacesResponse 

type SetNetworkInterfacesResponse struct {
	RebootNeeded xsd.Boolean
}

type SetNetworkProtocols 

type SetNetworkProtocols struct {
	XMLName          string                         `xml:"tds:SetNetworkProtocols"`
	NetworkProtocols []onvif.NetworkProtocolRequest `xml:"tds:NetworkProtocols"`
}

type SetNetworkProtocolsFunction 

type SetNetworkProtocolsFunction struct{}

func (*SetNetworkProtocolsFunction) Request 

func (_ *SetNetworkProtocolsFunction) Request() interface{}

func (*SetNetworkProtocolsFunction) Response 

func (_ *SetNetworkProtocolsFunction) Response() interface{}

type SetNetworkProtocolsResponse 

type SetNetworkProtocolsResponse struct {
}

type SetRelayOutputSettings 

type SetRelayOutputSettings struct {
	XMLName          string                    `xml:"tds:SetRelayOutputSettings"`
	RelayOutputToken onvif.ReferenceToken      `xml:"tds:RelayOutputToken"`
	Properties       onvif.RelayOutputSettings `xml:"tds:Properties"`
}

type SetRelayOutputSettingsFunction 

type SetRelayOutputSettingsFunction struct{}

func (*SetRelayOutputSettingsFunction) Request 

func (_ *SetRelayOutputSettingsFunction) Request() interface{}

func (*SetRelayOutputSettingsFunction) Response 

func (_ *SetRelayOutputSettingsFunction) Response() interface{}

type SetRelayOutputSettingsResponse 

type SetRelayOutputSettingsResponse struct {
}

type SetRelayOutputState 

type SetRelayOutputState struct {
	XMLName          string                  `xml:"tds:SetRelayOutputState"`
	RelayOutputToken onvif.ReferenceToken    `xml:"tds:RelayOutputToken"`
	LogicalState     onvif.RelayLogicalState `xml:"tds:LogicalState"`
}

type SetRelayOutputStateFunction 

type SetRelayOutputStateFunction struct{}

func (*SetRelayOutputStateFunction) Request 

func (_ *SetRelayOutputStateFunction) Request() interface{}

func (*SetRelayOutputStateFunction) Response 

func (_ *SetRelayOutputStateFunction) Response() interface{}

type SetRelayOutputStateResponse 

type SetRelayOutputStateResponse struct {
}

type SetRemoteDiscoveryMode 

type SetRemoteDiscoveryMode struct {
	XMLName             string              `xml:"tds:SetRemoteDiscoveryMode"`
	RemoteDiscoveryMode onvif.DiscoveryMode `xml:"tds:RemoteDiscoveryMode"`
}

type SetRemoteDiscoveryModeFunction 

type SetRemoteDiscoveryModeFunction struct{}

func (*SetRemoteDiscoveryModeFunction) Request 

func (_ *SetRemoteDiscoveryModeFunction) Request() interface{}

func (*SetRemoteDiscoveryModeFunction) Response 

func (_ *SetRemoteDiscoveryModeFunction) Response() interface{}

type SetRemoteDiscoveryModeResponse 

type SetRemoteDiscoveryModeResponse struct {
}

type SetRemoteUser 

type SetRemoteUser struct {
	XMLName    string           `xml:"tds:SetRemoteUser"`
	RemoteUser onvif.RemoteUser `xml:"tds:RemoteUser"`
}

type SetRemoteUserFunction 

type SetRemoteUserFunction struct{}

func (*SetRemoteUserFunction) Request 

func (_ *SetRemoteUserFunction) Request() interface{}

func (*SetRemoteUserFunction) Response 

func (_ *SetRemoteUserFunction) Response() interface{}

type SetRemoteUserResponse 

type SetRemoteUserResponse struct {
}

type SetScopes 

type SetScopes struct {
	XMLName string       `xml:"tds:SetScopes"`
	Scopes  []xsd.AnyURI `xml:"tds:Scopes"`
}

SetScopes and its properties are defined in the Onvif specification: https://www.onvif.org/ver10/device/wsdl/devicemgmt.wsdl#op.SetScopes

type SetScopesFunction 

type SetScopesFunction struct{}

func (*SetScopesFunction) Request 

func (_ *SetScopesFunction) Request() interface{}

func (*SetScopesFunction) Response 

func (_ *SetScopesFunction) Response() interface{}

type SetScopesResponse 

type SetScopesResponse struct {
}

type SetStorageConfiguration 

type SetStorageConfiguration struct {
	XMLName              string `xml:"tds:SetStorageConfiguration"`
	StorageConfiguration struct {
		Token xsd.String               `xml:"token,attr"`
		Data  StorageConfigurationData `xml:"tds:Data"`
	} `xml:"tds:StorageConfiguration"`
}

type SetStorageConfigurationFunction 

type SetStorageConfigurationFunction struct{}

func (*SetStorageConfigurationFunction) Request 

func (_ *SetStorageConfigurationFunction) Request() interface{}

func (*SetStorageConfigurationFunction) Response 

func (_ *SetStorageConfigurationFunction) Response() interface{}

type SetStorageConfigurationResponse 

type SetStorageConfigurationResponse struct {
}

type SetSystemDateAndTime 

type SetSystemDateAndTime struct {
	XMLName         string                 `xml:"tds:SetSystemDateAndTime,omitempty"`
	DateTimeType    *onvif.SetDateTimeType `xml:"tds:DateTimeType,omitempty"`
	DaylightSavings *xsd.Boolean           `xml:"tds:DaylightSavings,omitempty"`
	TimeZone        *onvif.TimeZone        `xml:"tds:TimeZone,omitempty"`
	UTCDateTime     *onvif.DateTimeRequest `xml:"tds:UTCDateTime,omitempty"`
}

SetSystemDateAndTime and its properties are defined in the Onvif specification: https://www.onvif.org/ver10/device/wsdl/devicemgmt.wsdl#op.SetSystemDateAndTime

type SetSystemDateAndTimeFunction 

type SetSystemDateAndTimeFunction struct{}

func (*SetSystemDateAndTimeFunction) Request 

func (_ *SetSystemDateAndTimeFunction) Request() interface{}

func (*SetSystemDateAndTimeFunction) Response 

func (_ *SetSystemDateAndTimeFunction) Response() interface{}

type SetSystemDateAndTimeResponse 

type SetSystemDateAndTimeResponse struct {
}

type SetSystemFactoryDefault 

type SetSystemFactoryDefault struct {
	XMLName        string                   `xml:"tds:SetSystemFactoryDefault"`
	FactoryDefault onvif.FactoryDefaultType `xml:"tds:FactoryDefault"`
}

SetSystemFactoryDefault and its properties are defined in the Onvif specification: https://www.onvif.org/ver10/device/wsdl/devicemgmt.wsdl#op.SetSystemFactoryDefault

type SetSystemFactoryDefaultFunction 

type SetSystemFactoryDefaultFunction struct{}

func (*SetSystemFactoryDefaultFunction) Request 

func (_ *SetSystemFactoryDefaultFunction) Request() interface{}

func (*SetSystemFactoryDefaultFunction) Response 

func (_ *SetSystemFactoryDefaultFunction) Response() interface{}

type SetSystemFactoryDefaultResponse 

type SetSystemFactoryDefaultResponse struct {
}

type SetUser 

type SetUser struct {
	XMLName string              `xml:"tds:SetUser"`
	User    []onvif.UserRequest `xml:"tds:User"`
}

SetUser and its properties are defined in the Onvif specification: https://www.onvif.org/ver10/device/wsdl/devicemgmt.wsdl#op.SetUser

type SetUserFunction 

type SetUserFunction struct{}

func (*SetUserFunction) Request 

func (_ *SetUserFunction) Request() interface{}

func (*SetUserFunction) Response 

func (_ *SetUserFunction) Response() interface{}

type SetUserResponse 

type SetUserResponse struct {
}

type SetZeroConfiguration 

type SetZeroConfiguration struct {
	XMLName        string               `xml:"tds:SetZeroConfiguration"`
	InterfaceToken onvif.ReferenceToken `xml:"tds:InterfaceToken"`
	Enabled        xsd.Boolean          `xml:"tds:Enabled"`
}

type SetZeroConfigurationFunction 

type SetZeroConfigurationFunction struct{}

func (*SetZeroConfigurationFunction) Request 

func (_ *SetZeroConfigurationFunction) Request() interface{}

func (*SetZeroConfigurationFunction) Response 

func (_ *SetZeroConfigurationFunction) Response() interface{}

type SetZeroConfigurationResponse 

type SetZeroConfigurationResponse struct {
}

type StartFirmwareUpgrade 

type StartFirmwareUpgrade struct {
	XMLName string `xml:"tds:StartFirmwareUpgrade"`
}

type StartFirmwareUpgradeFunction 

type StartFirmwareUpgradeFunction struct{}

func (*StartFirmwareUpgradeFunction) Request 

func (_ *StartFirmwareUpgradeFunction) Request() interface{}

func (*StartFirmwareUpgradeFunction) Response 

func (_ *StartFirmwareUpgradeFunction) Response() interface{}

type StartFirmwareUpgradeResponse 

type StartFirmwareUpgradeResponse struct {
	UploadUri        xsd.AnyURI
	UploadDelay      xsd.Duration
	ExpectedDownTime xsd.Duration
}

type StartSystemRestore 

type StartSystemRestore struct {
	XMLName string `xml:"tds:StartSystemRestore"`
}

type StartSystemRestoreFunction 

type StartSystemRestoreFunction struct{}

func (*StartSystemRestoreFunction) Request 

func (_ *StartSystemRestoreFunction) Request() interface{}

func (*StartSystemRestoreFunction) Response 

func (_ *StartSystemRestoreFunction) Response() interface{}

type StartSystemRestoreResponse 

type StartSystemRestoreResponse struct {
	UploadUri        xsd.AnyURI
	ExpectedDownTime xsd.Duration
}

type StorageConfiguration 

type StorageConfiguration struct {
	onvif.DeviceEntity
	Data struct {
		Type       xsd.String `xml:"type,attr"`
		Region     string
		LocalPath  xsd.AnyURI
		StorageUri xsd.AnyURI
		User       struct {
			UserName  xsd.String
			Password  xsd.String  `json:",omitempty"`
			Extension xsd.AnyType `json:",omitempty"`
		}
		Extension xsd.AnyURI `json:",omitempty"`
	}
}

type StorageConfigurationData 

type StorageConfigurationData struct {
	Type       xsd.String     `xml:"type,attr"`
	Region     string         `xml:"tds:Region,omitempty"`
	LocalPath  xsd.AnyURI     `xml:"tds:LocalPath"`
	StorageUri xsd.AnyURI     `xml:"tds:StorageUri"`
	User       UserCredential `xml:"tds:User"`
	Extension  xsd.AnyURI     `xml:"tds:Extension"`
}

type SystemCapabilities 

type SystemCapabilities struct {
	DiscoveryResolve         xsd.Boolean          `xml:"DiscoveryResolve,attr"`
	DiscoveryBye             xsd.Boolean          `xml:"DiscoveryBye,attr"`
	RemoteDiscovery          xsd.Boolean          `xml:"RemoteDiscovery,attr"`
	SystemBackup             xsd.Boolean          `xml:"SystemBackup,attr"`
	SystemLogging            xsd.Boolean          `xml:"SystemLogging,attr"`
	FirmwareUpgrade          xsd.Boolean          `xml:"FirmwareUpgrade,attr"`
	HttpFirmwareUpgrade      xsd.Boolean          `xml:"HttpFirmwareUpgrade,attr"`
	HttpSystemBackup         xsd.Boolean          `xml:"HttpSystemBackup,attr"`
	HttpSystemLogging        xsd.Boolean          `xml:"HttpSystemLogging,attr"`
	HttpSupportInformation   xsd.Boolean          `xml:"HttpSupportInformation,attr"`
	StorageConfiguration     xsd.Boolean          `xml:"StorageConfiguration,attr"`
	MaxStorageConfigurations int                  `xml:"MaxStorageConfigurations,attr"`
	StorageTypesSupported    onvif.StringAttrList `xml:"StorageTypesSupported,attr"`
	GeoLocationEntries       int                  `xml:"GeoLocationEntries,attr"`
	AutoGeo                  onvif.StringAttrList `xml:"AutoGeo,attr"`
}

type SystemReboot 

type SystemReboot struct {
	XMLName string `xml:"tds:SystemReboot"`
}

SystemReboot and its properties are defined in the Onvif specification: https://www.onvif.org/ver10/device/wsdl/devicemgmt.wsdl#op.SystemReboot

type SystemRebootFunction 

type SystemRebootFunction struct{}

func (*SystemRebootFunction) Request 

func (_ *SystemRebootFunction) Request() interface{}

func (*SystemRebootFunction) Response 

func (_ *SystemRebootFunction) Response() interface{}

type SystemRebootResponse 

type SystemRebootResponse struct {
	Message string
}

type UpgradeSystemFirmware 

type UpgradeSystemFirmware struct {
	XMLName  string               `xml:"tds:UpgradeSystemFirmware"`
	Firmware onvif.AttachmentData `xml:"tds:Firmware"`
}

type UpgradeSystemFirmwareFunction 

type UpgradeSystemFirmwareFunction struct{}

func (*UpgradeSystemFirmwareFunction) Request 

func (_ *UpgradeSystemFirmwareFunction) Request() interface{}

func (*UpgradeSystemFirmwareFunction) Response 

func (_ *UpgradeSystemFirmwareFunction) Response() interface{}

type UpgradeSystemFirmwareResponse 

type UpgradeSystemFirmwareResponse struct {
	Message string
}

type UserCredential 

type UserCredential struct {
	UserName  xsd.String  `xml:"tds:UserName"`
	Password  xsd.String  `xml:"tds:Password"`
	Extension xsd.AnyType `xml:"tds:Extension"`
}

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.