onvif

package
v0.1.2 Latest Latest
Warning

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

 Go to latest Published: Nov 20, 2024 License: MIT Imports: 1 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AACDecOptions 

type AACDecOptions struct {
	Bitrate         IntList
	SampleRateRange IntList
}

type AbsoluteFocus 

type AbsoluteFocus struct {
	Position xsd.Float `xml:"onvif:Position"`
	Speed    xsd.Float `xml:"onvif:Speed"`
}

type AnalyticsCapabilities 

type AnalyticsCapabilities struct {
	XAddr                  xsd.AnyURI
	RuleSupport            xsd.Boolean
	AnalyticsModuleSupport xsd.Boolean
}

AnalyticsCapabilities Check

type AnalyticsDeviceCapabilities 

type AnalyticsDeviceCapabilities struct {
	XAddr       xsd.AnyURI
	RuleSupport xsd.Boolean
	Extension   AnalyticsDeviceExtension
}

type AnalyticsDeviceExtension 

type AnalyticsDeviceExtension xsd.AnyType

type AnalyticsEngineConfiguration 

type AnalyticsEngineConfiguration struct {
	AnalyticsModule Config                                `xml:"onvif:AnalyticsModule"`
	Extension       AnalyticsEngineConfigurationExtension `xml:"onvif:Extension"`
}

type AnalyticsEngineConfigurationExtension 

type AnalyticsEngineConfigurationExtension xsd.AnyType

type AttachmentData 

type AttachmentData struct {
	ContentType ContentType `xml:"contentType,attr"`
	Include     Include     `xml:"inc:Include"`
}

type AudioDecoderConfiguration 

type AudioDecoderConfiguration struct {
	ConfigurationEntity
}

type AudioDecoderConfigurationOptions 

type AudioDecoderConfigurationOptions struct {
	AACDecOptions  AACDecOptions
	G711DecOptions G711DecOptions
	G726DecOptions G726DecOptions
	Extension      AudioDecoderConfigurationOptionsExtension
}

type AudioDecoderConfigurationOptionsExtension 

type AudioDecoderConfigurationOptionsExtension xsd.AnyType

type AudioEncoderConfiguration 

type AudioEncoderConfiguration struct {
	ConfigurationEntity
	Encoding       AudioEncoding          `xml:"onvif:Encoding"`
	Bitrate        int                    `xml:"onvif:Bitrate"`
	SampleRate     int                    `xml:"onvif:SampleRate"`
	Multicast      MulticastConfiguration `xml:"onvif:Multicast"`
	SessionTimeout xsd.Duration           `xml:"onvif:SessionTimeout"`
}

type AudioEncoderConfigurationOption 

type AudioEncoderConfigurationOption struct {
	Encoding       AudioEncoding
	BitrateList    IntList
	SampleRateList IntList
}

type AudioEncoderConfigurationOptions 

type AudioEncoderConfigurationOptions struct {
	Options AudioEncoderConfigurationOption
}

type AudioEncoding 

type AudioEncoding xsd.String

type AudioOutput 

type AudioOutput struct {
	DeviceEntity
}

type AudioOutputConfiguration 

type AudioOutputConfiguration struct {
	ConfigurationEntity
	OutputToken ReferenceToken `xml:"onvif:OutputToken"`
	SendPrimacy xsd.AnyURI     `xml:"onvif:SendPrimacy"`
	OutputLevel int            `xml:"onvif:OutputLevel"`
}

type AudioOutputConfigurationOptions 

type AudioOutputConfigurationOptions struct {
	OutputTokensAvailable ReferenceToken
	SendPrimacyOptions    xsd.AnyURI
	OutputLevelRange      IntRange
}

type AudioSource 

type AudioSource struct {
	DeviceEntity
	Channels int
}

type AudioSourceConfiguration 

type AudioSourceConfiguration struct {
	ConfigurationEntity
	SourceToken ReferenceToken `xml:"onvif:SourceToken"`
}

type AudioSourceConfigurationOptions 

type AudioSourceConfigurationOptions struct {
	InputTokensAvailable ReferenceToken
	Extension            AudioSourceOptionsExtension
}

type AudioSourceOptionsExtension 

type AudioSourceOptionsExtension xsd.AnyType

type AutoFocusMode 

type AutoFocusMode xsd.String

type AuxiliaryData 

type AuxiliaryData xsd.String

TODO: restriction

type BacklightCompensation 

type BacklightCompensation struct {
	Mode  BacklightCompensationMode
	Level float64
}

type BacklightCompensation20 

type BacklightCompensation20 struct {
	Mode  BacklightCompensationMode `xml:"onvif:Mode"`
	Level float64                   `xml:"onvif:Level"`
}

type BacklightCompensationMode 

type BacklightCompensationMode xsd.String

type BackupFile 

type BackupFile struct {
	Name string         `xml:"onvif:Name"`
	Data AttachmentData `xml:"onvif:Data"`
}

type BinaryData 

type BinaryData struct {
	X    ContentType      `xml:"xmime:contentType,attr"`
	Data xsd.Base64Binary `xml:"onvif:Data"`
}

TODO: attribite <xs:attribute ref="xmime:contentType" use="optional"/>

type Capabilities 

type Capabilities struct {
	Analytics AnalyticsCapabilities
	Device    DeviceCapabilities
	Events    EventCapabilities
	Imaging   ImagingCapabilities
	Media     MediaCapabilities
	PTZ       PTZCapabilities
	Extension CapabilitiesExtension
}

Capabilities of device

type CapabilitiesExtension 

type CapabilitiesExtension struct {
	DeviceIO        DeviceIOCapabilities
	Display         DisplayCapabilities
	Recording       RecordingCapabilities
	Search          SearchCapabilities
	Replay          ReplayCapabilities
	Receiver        ReceiverCapabilities
	AnalyticsDevice AnalyticsDeviceCapabilities
	Extensions      CapabilitiesExtension2
}

type CapabilitiesExtension2 

type CapabilitiesExtension2 xsd.AnyType

type CapabilityCategory 

type CapabilityCategory xsd.String

type Certificate 

type Certificate struct {
	CertificateID xsd.Token  `xml:"onvif:CertificateID"`
	Certificate   BinaryData `xml:"onvif:Certificate"`
}

type CertificateInformation 

type CertificateInformation struct {
	CertificateID      xsd.Token
	IssuerDN           xsd.String
	SubjectDN          xsd.String
	KeyUsage           CertificateUsage
	ExtendedKeyUsage   CertificateUsage
	KeyLength          xsd.Int
	Version            xsd.String
	SerialNum          xsd.String
	SignatureAlgorithm xsd.String
	Validity           DateTimeRange
	Extension          CertificateInformationExtension
}

type CertificateInformationExtension 

type CertificateInformationExtension xsd.AnyType

type CertificateStatus 

type CertificateStatus struct {
	CertificateID xsd.Token   `xml:"onvif:CertificateID"`
	Status        xsd.Boolean `xml:"onvif:Status"`
}

type CertificateUsage 

type CertificateUsage struct {
	Critical         xsd.Boolean `xml:"Critical,attr"`
	CertificateUsage xsd.String
}

type CertificateWithPrivateKey 

type CertificateWithPrivateKey struct {
	CertificateID xsd.Token  `xml:"onvif:CertificateID"`
	Certificate   BinaryData `xml:"onvif:Certificate"`
	PrivateKey    BinaryData `xml:"onvif:PrivateKey"`
}

type Color 

type Color struct {
	X          float64    `xml:"X,attr"`
	Y          float64    `xml:"Y,attr"`
	Z          float64    `xml:"Z,attr"`
	Colorspace xsd.AnyURI `xml:"Colorspace,attr"`
}

type ColorOptions 

type ColorOptions struct {
	ColorList       Color
	ColorspaceRange ColorspaceRange
}

type ColorspaceRange 

type ColorspaceRange struct {
	X          FloatRange
	Y          FloatRange
	Z          FloatRange
	Colorspace xsd.AnyURI
}

type Config 

type Config struct {
	Name       string    `xml:"Name,attr"`
	Type       xsd.QName `xml:"Type,attr"`
	Parameters ItemList  `xml:"onvif:Parameters"`
}

type ConfigurationEntity 

type ConfigurationEntity struct {
	Token    ReferenceToken `xml:"token,attr"`
	Name     Name           `xml:"onvif:Name"`
	UseCount int            `xml:"onvif:UseCount"`
}

type ContentType 

type ContentType string // minLength value="3"

type ContinuousFocus 

type ContinuousFocus struct {
	Speed xsd.Float `xml:"onvif:Speed"`
}

type DNSInformation 

type DNSInformation struct {
	FromDHCP     xsd.Boolean
	SearchDomain xsd.Token
	DNSFromDHCP  IPAddress
	DNSManual    IPAddress
	Extension    DNSInformationExtension
}

type DNSInformationExtension 

type DNSInformationExtension xsd.AnyType

type DNSName 

type DNSName xsd.Token

type Date 

type Date struct {
	Year  xsd.Int `xml:"onvif:Year"`
	Month xsd.Int `xml:"onvif:Month"`
	Day   xsd.Int `xml:"onvif:Day"`
}

type DateTime 

type DateTime struct {
	Time Time `xml:"onvif:Time"`
	Date Date `xml:"onvif:Date"`
}

type DateTimeRange 

type DateTimeRange struct {
	From  xsd.DateTime
	Until xsd.DateTime
}

type Defogging 

type Defogging struct {
	Mode      string
	Level     float64
	Extension DefoggingExtension
}

type DefoggingExtension 

type DefoggingExtension xsd.AnyType

type Description 

type Description struct {
	Description string
}

type DeviceCapabilities 

type DeviceCapabilities struct {
	XAddr     xsd.AnyURI
	Network   NetworkCapabilities
	System    SystemCapabilities
	IO        IOCapabilities
	Security  SecurityCapabilities
	Extension DeviceCapabilitiesExtension
}

DeviceCapabilities Check

type DeviceCapabilitiesExtension 

type DeviceCapabilitiesExtension xsd.AnyType

type DeviceEntity 

type DeviceEntity struct {
	Token ReferenceToken `xml:"token,attr"`
}

type DeviceIOCapabilities 

type DeviceIOCapabilities struct {
	XAddr        xsd.AnyURI
	VideoSources int
	VideoOutputs int
	AudioSources int
	AudioOutputs int
	RelayOutputs int
}

type DiscoveryMode 

type DiscoveryMode xsd.String

type DisplayCapabilities 

type DisplayCapabilities struct {
	XAddr       xsd.AnyURI
	FixedLayout xsd.Boolean
}

type Dot11AuthAndMangementSuite 

type Dot11AuthAndMangementSuite xsd.String

TODO: enumeration

type Dot11AvailableNetworks 

type Dot11AvailableNetworks struct {
	SSID                  Dot11SSIDType
	BSSID                 xsd.String
	AuthAndMangementSuite Dot11AuthAndMangementSuite
	PairCipher            Dot11Cipher
	GroupCipher           Dot11Cipher
	SignalStrength        Dot11SignalStrength
	Extension             Dot11AvailableNetworksExtension
}

type Dot11AvailableNetworksExtension 

type Dot11AvailableNetworksExtension xsd.AnyType

type Dot11Capabilities 

type Dot11Capabilities struct {
	TKIP                  xsd.Boolean
	ScanAvailableNetworks xsd.Boolean
	MultipleConfiguration xsd.Boolean
	AdHocStationMode      xsd.Boolean
	WEP                   xsd.Boolean
}

type Dot11Cipher 

type Dot11Cipher xsd.String

TODO: enumeration

type Dot11Configuration 

type Dot11Configuration struct {
	SSID     Dot11SSIDType                  `xml:"onvif:SSID"`
	Mode     Dot11StationMode               `xml:"onvif:Mode"`
	Alias    Name                           `xml:"onvif:Alias"`
	Priority NetworkInterfaceConfigPriority `xml:"onvif:Priority"`
	Security Dot11SecurityConfiguration     `xml:"onvif:Security"`
}

type Dot11PSK 

type Dot11PSK xsd.HexBinary

type Dot11PSKPassphrase 

type Dot11PSKPassphrase xsd.String

type Dot11PSKSet 

type Dot11PSKSet struct {
	Key        Dot11PSK             `xml:"onvif:Key"`
	Passphrase Dot11PSKPassphrase   `xml:"onvif:Passphrase"`
	Extension  Dot11PSKSetExtension `xml:"onvif:Extension"`
}

type Dot11PSKSetExtension 

type Dot11PSKSetExtension xsd.AnyType

type Dot11SSIDType 

type Dot11SSIDType xsd.HexBinary

TODO: restrictions

type Dot11SecurityConfiguration 

type Dot11SecurityConfiguration struct {
	Mode      Dot11SecurityMode                   `xml:"onvif:Mode"`
	Algorithm Dot11Cipher                         `xml:"onvif:Algorithm"`
	PSK       Dot11PSKSet                         `xml:"onvif:PSK"`
	Dot1X     ReferenceToken                      `xml:"onvif:Dot1X"`
	Extension Dot11SecurityConfigurationExtension `xml:"onvif:Extension"`
}

type Dot11SecurityConfigurationExtension 

type Dot11SecurityConfigurationExtension xsd.AnyType

type Dot11SecurityMode 

type Dot11SecurityMode xsd.String

TODO: enumeration

type Dot11SignalStrength 

type Dot11SignalStrength xsd.String

TODO: enumeration

type Dot11StationMode 

type Dot11StationMode xsd.String

TODO: enumeration

type Dot11Status 

type Dot11Status struct {
	SSID              Dot11SSIDType
	BSSID             xsd.String
	PairCipher        Dot11Cipher
	GroupCipher       Dot11Cipher
	SignalStrength    Dot11SignalStrength
	ActiveConfigAlias ReferenceToken
}

type Dot1XConfiguration 

type Dot1XConfiguration struct {
	Dot1XConfigurationToken ReferenceToken              `xml:"onvif:Dot1XConfigurationToken"`
	Identity                xsd.String                  `xml:"onvif:Identity"`
	AnonymousID             xsd.String                  `xml:"onvif:AnonymousID,omitempty"`
	EAPMethod               xsd.Int                     `xml:"onvif:EAPMethod"`
	CACertificateID         xsd.Token                   `xml:"onvif:CACertificateID,omitempty"`
	EAPMethodConfiguration  EAPMethodConfiguration      `xml:"onvif:EAPMethodConfiguration,omitempty"`
	Extension               Dot1XConfigurationExtension `xml:"onvif:Extension,omitempty"`
}

type Dot1XConfigurationExtension 

type Dot1XConfigurationExtension xsd.AnyType

type Dot3Configuration 

type Dot3Configuration xsd.String

type Duplex 

type Duplex xsd.String

TODO: enum

type DurationRange 

type DurationRange struct {
	Min xsd.Duration
	Max xsd.Duration
}

type DynamicDNSInformation 

type DynamicDNSInformation struct {
	Type      DynamicDNSType
	Name      DNSName
	TTL       xsd.Duration
	Extension DynamicDNSInformationExtension
}

type DynamicDNSInformationExtension 

type DynamicDNSInformationExtension xsd.AnyType

type DynamicDNSType 

type DynamicDNSType xsd.String

TODO: enumeration

type EAPMethodConfiguration 

type EAPMethodConfiguration struct {
	TLSConfiguration TLSConfiguration   `xml:"onvif:TLSConfiguration,omitempty"`
	Password         xsd.String         `xml:"onvif:Password,omitempty"`
	Extension        EapMethodExtension `xml:"onvif:Extension,omitempty"`
}

type EFlip 

type EFlip struct {
	Mode EFlipMode `xml:"onvif:Mode"`
}

type EFlipMode 

type EFlipMode xsd.String

type EFlipOptions 

type EFlipOptions struct {
	Mode      EFlipMode
	Extension EFlipOptionsExtension
}

type EFlipOptionsExtension 

type EFlipOptionsExtension xsd.AnyType

type EapMethodExtension 

type EapMethodExtension xsd.AnyType

type ElementItem 

type ElementItem struct {
	Name string `xml:"Name,attr"`
}

type EncodingTypes 

type EncodingTypes struct {
	EncodingTypes []string
}

type EventCapabilities 

type EventCapabilities struct {
	XAddr                                         xsd.AnyURI
	WSSubscriptionPolicySupport                   xsd.Boolean
	WSPullPointSupport                            xsd.Boolean
	WSPausableSubscriptionManagerInterfaceSupport xsd.Boolean
}

type EventSubscription 

type EventSubscription struct {
	Filter             FilterType `xml:"onvif:Filter"`
	SubscriptionPolicy `xml:"onvif:SubscriptionPolicy"`
}

type Exposure 

type Exposure struct {
	Mode            ExposureMode
	Priority        ExposurePriority
	Window          Rectangle
	MinExposureTime float64
	MaxExposureTime float64
	MinGain         float64
	MaxGain         float64
	MinIris         float64
	MaxIris         float64
	ExposureTime    float64
	Gain            float64
	Iris            float64
}

type Exposure20 

type Exposure20 struct {
	Mode            ExposureMode     `xml:"onvif:Mode,omitempty"`
	Priority        ExposurePriority `xml:"onvif:Priority,omitempty"`
	Window          Rectangle        `xml:"onvif:Window,omitempty"`
	MinExposureTime float64          `xml:"onvif:MinExposureTime,omitempty"`
	MaxExposureTime float64          `xml:"onvif:MaxExposureTime,omitempty"`
	MinGain         float64          `xml:"onvif:MinGain,omitempty"`
	MaxGain         float64          `xml:"onvif:MaxGain,omitempty"`
	MinIris         float64          `xml:"onvif:MinIris,omitempty"`
	MaxIris         float64          `xml:"onvif:MaxIris,omitempty"`
	ExposureTime    float64          `xml:"onvif:ExposureTime,omitempty"`
	Gain            float64          `xml:"onvif:Gain,omitempty"`
	Iris            float64          `xml:"onvif:Iris,omitempty"`
}

type ExposureMode 

type ExposureMode xsd.String

type ExposurePriority 

type ExposurePriority xsd.String

type FactoryDefaultType 

type FactoryDefaultType xsd.String

type FilterType 

type FilterType xsd.AnyType

type FloatRange 

type FloatRange struct {
	Min float64 `xml:"Min"`
	Max float64 `xml:"Max"`
}

type FocusConfiguration 

type FocusConfiguration struct {
	AutoFocusMode AutoFocusMode
	DefaultSpeed  float64
	NearLimit     float64
	FarLimit      float64
}

type FocusConfiguration20 

type FocusConfiguration20 struct {
	AutoFocusMode AutoFocusMode                 `xml:"onvif:AutoFocusMode"`
	DefaultSpeed  float64                       `xml:"onvif:DefaultSpeed"`
	NearLimit     float64                       `xml:"onvif:NearLimit"`
	FarLimit      float64                       `xml:"onvif:FarLimit"`
	Extension     FocusConfiguration20Extension `xml:"onvif:Extension"`
}

type FocusConfiguration20Extension 

type FocusConfiguration20Extension xsd.AnyType

type FocusMove 

type FocusMove struct {
	Absolute   AbsoluteFocus   `xml:"onvif:Absolute"`
	Relative   RelativeFocus   `xml:"onvif:Relative"`
	Continuous ContinuousFocus `xml:"onvif:Continuous"`
}

type G711DecOptions 

type G711DecOptions struct {
	Bitrate         IntList
	SampleRateRange IntList
}

type G726DecOptions 

type G726DecOptions struct {
	Bitrate         IntList
	SampleRateRange IntList
}

type GeoLocation 

type GeoLocation struct {
	Lon       xsd.Double `xml:"lon,attr"`
	Lat       xsd.Double `xml:"lat,attr"`
	Elevation xsd.Float  `xml:"elevation,attr"`
}

type GeoOrientation 

type GeoOrientation struct {
	Roll  xsd.Float `xml:"roll,attr"`
	Pitch xsd.Float `xml:"pitch,attr"`
	Yaw   xsd.Float `xml:"yaw,attr"`
}

type H264Configuration 

type H264Configuration struct {
	GovLength   xsd.Int     `xml:"onvif:GovLength"`
	H264Profile H264Profile `xml:"onvif:H264Profile"`
}

type H264Options 

type H264Options struct {
	ResolutionsAvailable  VideoResolution
	GovLengthRange        IntRange
	FrameRateRange        IntRange
	EncodingIntervalRange IntRange
	H264ProfilesSupported H264Profile
}

type H264Options2 

type H264Options2 struct {
	H264Options
	BitrateRange IntRange
}

type H264Profile 

type H264Profile xsd.String

type HostnameInformation 

type HostnameInformation struct {
	FromDHCP  xsd.Boolean
	Name      xsd.Token
	Extension HostnameInformationExtension
}

type HostnameInformationExtension 

type HostnameInformationExtension xsd.AnyType

type HwAddress 

type HwAddress xsd.Token

type IANA_IfTypes 

type IANA_IfTypes xsd.Int

type IOCapabilities 

type IOCapabilities struct {
	InputConnectors int
	RelayOutputs    int
	Extension       IOCapabilitiesExtension
}

type IOCapabilitiesExtension 

type IOCapabilitiesExtension struct {
	Auxiliary         xsd.Boolean
	AuxiliaryCommands AuxiliaryData
	Extension         IOCapabilitiesExtension2
}

type IOCapabilitiesExtension2 

type IOCapabilitiesExtension2 xsd.AnyType

type IPAddress 

type IPAddress struct {
	Type        IPType      `xml:"onvif:Type"`
	IPv4Address IPv4Address `xml:"onvif:IPv4Address"`
	IPv6Address IPv6Address `xml:"onvif:IPv6Address"`
}

type IPAddressFilter 

type IPAddressFilter struct {
	Type        IPAddressFilterType      `xml:"onvif:Type"`
	IPv4Address PrefixedIPv4Address      `xml:"onvif:IPv4Address,omitempty"`
	IPv6Address PrefixedIPv6Address      `xml:"onvif:IPv6Address,omitempty"`
	Extension   IPAddressFilterExtension `xml:"onvif:Extension,omitempty"`
}

type IPAddressFilterExtension 

type IPAddressFilterExtension xsd.AnyType

type IPAddressFilterType 

type IPAddressFilterType xsd.String

enum { 'Allow', 'Deny' } TODO: enumeration

type IPType 

type IPType xsd.String

type IPv4Address 

type IPv4Address xsd.Token

IPv4 address

type IPv4Configuration 

type IPv4Configuration struct {
	Manual    PrefixedIPv4Address
	LinkLocal PrefixedIPv4Address
	FromDHCP  PrefixedIPv4Address
	DHCP      xsd.Boolean
}

type IPv4NetworkInterface 

type IPv4NetworkInterface struct {
	Enabled xsd.Boolean
	Config  IPv4Configuration
}

type IPv4NetworkInterfaceSetConfiguration 

type IPv4NetworkInterfaceSetConfiguration struct {
	Enabled xsd.Boolean         `xml:"onvif:Enabled"`
	Manual  PrefixedIPv4Address `xml:"onvif:Manual"`
	DHCP    xsd.Boolean         `xml:"onvif:DHCP"`
}

type IPv6Address 

type IPv6Address xsd.Token

IPv6 address

type IPv6Configuration 

type IPv6Configuration struct {
	AcceptRouterAdvert xsd.Boolean
	DHCP               IPv6DHCPConfiguration
	Manual             PrefixedIPv6Address
	LinkLocal          PrefixedIPv6Address
	FromDHCP           PrefixedIPv6Address
	FromRA             PrefixedIPv6Address
	Extension          IPv6ConfigurationExtension
}

type IPv6ConfigurationExtension 

type IPv6ConfigurationExtension xsd.AnyType

type IPv6DHCPConfiguration 

type IPv6DHCPConfiguration xsd.String

TODO: enumeration

type IPv6NetworkInterface 

type IPv6NetworkInterface struct {
	Enabled xsd.Boolean
	Config  IPv6Configuration
}

type IPv6NetworkInterfaceSetConfiguration 

type IPv6NetworkInterfaceSetConfiguration struct {
	Enabled            xsd.Boolean           `xml:"onvif:Enabled"`
	AcceptRouterAdvert xsd.Boolean           `xml:"onvif:AcceptRouterAdvert"`
	Manual             PrefixedIPv6Address   `xml:"onvif:Manual"`
	DHCP               IPv6DHCPConfiguration `xml:"onvif:DHCP"`
}

type ImageStabilization 

type ImageStabilization struct {
	Mode      ImageStabilizationMode      `xml:"onvif:Mode"`
	Level     float64                     `xml:"onvif:Level"`
	Extension ImageStabilizationExtension `xml:"onvif:Extension"`
}

type ImageStabilizationExtension 

type ImageStabilizationExtension xsd.AnyType

type ImageStabilizationMode 

type ImageStabilizationMode xsd.String

type ImagingCapabilities 

type ImagingCapabilities struct {
	XAddr xsd.AnyURI
}

type ImagingSettings 

type ImagingSettings struct {
	BacklightCompensation BacklightCompensation
	Brightness            float64
	ColorSaturation       float64
	Contrast              float64
	Exposure              Exposure
	Focus                 FocusConfiguration
	IrCutFilter           IrCutFilterMode
	Sharpness             float64
	WideDynamicRange      WideDynamicRange
	WhiteBalance          WhiteBalance
	Extension             ImagingSettingsExtension
}

type ImagingSettings20 

type ImagingSettings20 struct {
	BacklightCompensation *BacklightCompensation20    `xml:"onvif:BacklightCompensation"`
	Brightness            float64                     `xml:"onvif:Brightness,omitempty"`
	ColorSaturation       float64                     `xml:"onvif:ColorSaturation,omitempty"`
	Contrast              float64                     `xml:"onvif:Contrast,omitempty"`
	Exposure              *Exposure20                 `xml:"onvif:Exposure"`
	Focus                 *FocusConfiguration20       `xml:"onvif:Focus"`
	IrCutFilter           *IrCutFilterMode            `xml:"onvif:IrCutFilter"`
	Sharpness             float64                     `xml:"onvif:Sharpness,omitempty"`
	WideDynamicRange      *WideDynamicRange20         `xml:"onvif:WideDynamicRange"`
	WhiteBalance          *WhiteBalance20             `xml:"onvif:WhiteBalance"`
	Extension             *ImagingSettingsExtension20 `xml:"onvif:Extension"`
}

type ImagingSettingsExtension 

type ImagingSettingsExtension xsd.AnyType

type ImagingSettingsExtension20 

type ImagingSettingsExtension20 struct {
	ImageStabilization ImageStabilization          `xml:"onvif:ImageStabilization"`
	Extension          ImagingSettingsExtension202 `xml:"onvif:Extension"`
}

type ImagingSettingsExtension202 

type ImagingSettingsExtension202 struct {
	IrCutFilterAutoAdjustment IrCutFilterAutoAdjustment   `xml:"onvif:IrCutFilterAutoAdjustment"`
	Extension                 ImagingSettingsExtension203 `xml:"onvif:Extension"`
}

type ImagingSettingsExtension203 

type ImagingSettingsExtension203 struct {
	ToneCompensation ToneCompensation            `xml:"onvif:ToneCompensation"`
	Defogging        Defogging                   `xml:"onvif:Defogging"`
	NoiseReduction   NoiseReduction              `xml:"onvif:NoiseReduction"`
	Extension        ImagingSettingsExtension204 `xml:"onvif:Extension"`
}

type ImagingSettingsExtension204 

type ImagingSettingsExtension204 xsd.AnyType

type Include 

type Include struct {
	Href xsd.AnyURI `xml:"href,attr"`
}

type IntAttrList 

type IntAttrList struct {
	IntAttrList []int
}

type IntList 

type IntList struct {
	Items []int
}

type IntRange 

type IntRange struct {
	Min int
	Max int
}

type IntRectangle 

type IntRectangle struct {
	X      int `xml:"x,attr"`
	Y      int `xml:"y,attr"`
	Width  int `xml:"width,attr"`
	Height int `xml:"height,attr"`
}

type IntRectangleRange 

type IntRectangleRange struct {
	XRange      IntRange
	YRange      IntRange
	WidthRange  IntRange
	HeightRange IntRange
}

type IrCutFilterAutoAdjustment 

type IrCutFilterAutoAdjustment struct {
	BoundaryType   string                             `xml:"onvif:BoundaryType"`
	BoundaryOffset float64                            `xml:"onvif:BoundaryOffset"`
	ResponseTime   xsd.Duration                       `xml:"onvif:ResponseTime"`
	Extension      IrCutFilterAutoAdjustmentExtension `xml:"onvif:Extension"`
}

type IrCutFilterAutoAdjustmentExtension 

type IrCutFilterAutoAdjustmentExtension xsd.AnyType

type IrCutFilterMode 

type IrCutFilterMode xsd.String

type ItemList 

type ItemList struct {
	SimpleItem  SimpleItem        `xml:"onvif:SimpleItem"`
	ElementItem ElementItem       `xml:"onvif:ElementItem"`
	Extension   ItemListExtension `xml:"onvif:Extension"`
}

type ItemListExtension 

type ItemListExtension xsd.AnyType

type JpegOptions 

type JpegOptions struct {
	ResolutionsAvailable  VideoResolution
	FrameRateRange        IntRange
	EncodingIntervalRange IntRange
}

type JpegOptions2 

type JpegOptions2 struct {
	JpegOptions
	BitrateRange IntRange
}

type LensDescription 

type LensDescription struct {
	FocalLength float64        `xml:"FocalLength,attr"`
	Offset      LensOffset     `xml:"onvif:Offset"`
	Projection  LensProjection `xml:"onvif:Projection"`
	XFactor     float64        `xml:"onvif:XFactor"`
}

type LensOffset 

type LensOffset struct {
	X float64 `xml:"x,attr"`
	Y float64 `xml:"y,attr"`
}

type LensProjection 

type LensProjection struct {
	Angle         float64 `xml:"onvif:Angle"`
	Radius        float64 `xml:"onvif:Radius"`
	Transmittance float64 `xml:"onvif:Transmittance"`
}

type LocalLocation 

type LocalLocation struct {
	X xsd.Float `xml:"x,attr"`
	Y xsd.Float `xml:"y,attr"`
	Z xsd.Float `xml:"z,attr"`
}

type LocalOrientation 

type LocalOrientation struct {
	Lon       xsd.Double `xml:"lon,attr"`
	Lat       xsd.Double `xml:"lat,attr"`
	Elevation xsd.Float  `xml:"elevation,attr"`
}

type LocationEntity 

type LocationEntity struct {
	Entity    xsd.String     `xml:"Entity,attr"`
	Token     ReferenceToken `xml:"Token,attr"`
	Fixed     xsd.Boolean    `xml:"Fixed,attr"`
	GeoSource xsd.AnyURI     `xml:"GeoSource,attr"`
	AutoGeo   xsd.Boolean    `xml:"AutoGeo,attr"`

	GeoLocation      GeoLocation      `xml:"onvif:GeoLocation"`
	GeoOrientation   GeoOrientation   `xml:"onvif:GeoOrientation"`
	LocalLocation    LocalLocation    `xml:"onvif:LocalLocation"`
	LocalOrientation LocalOrientation `xml:"onvif:LocalOrientation"`
}

type MaximumNumberOfOSDs 

type MaximumNumberOfOSDs struct {
	Total       int `xml:"Total,attr"`
	Image       int `xml:"Image,attr"`
	PlainText   int `xml:"PlainText,attr"`
	Date        int `xml:"Date,attr"`
	Time        int `xml:"Time,attr"`
	DateAndTime int `xml:"DateAndTime,attr"`
}

type MediaCapabilities 

type MediaCapabilities struct {
	XAddr                 xsd.AnyURI
	StreamingCapabilities RealTimeStreamingCapabilities
	Extension             MediaCapabilitiesExtension
}

type MediaCapabilitiesExtension 

type MediaCapabilitiesExtension struct {
	ProfileCapabilities ProfileCapabilities
}

type MediaUri 

type MediaUri struct {
	Uri                 xsd.AnyURI
	InvalidAfterConnect bool
	InvalidAfterReboot  bool
	Timeout             xsd.Duration
}

type MetadataConfiguration 

type MetadataConfiguration struct {
	ConfigurationEntity
	CompressionType              string                         `xml:"CompressionType,attr"`
	PTZStatus                    PTZFilter                      `xml:"onvif:PTZStatus"`
	Events                       EventSubscription              `xml:"onvif:Events"`
	Analytics                    xsd.Boolean                    `xml:"onvif:Analytics"`
	Multicast                    MulticastConfiguration         `xml:"onvif:Multicast"`
	SessionTimeout               xsd.Duration                   `xml:"onvif:SessionTimeout"`
	AnalyticsEngineConfiguration AnalyticsEngineConfiguration   `xml:"onvif:AnalyticsEngineConfiguration"`
	Extension                    MetadataConfigurationExtension `xml:"onvif:Extension"`
}

type MetadataConfigurationExtension 

type MetadataConfigurationExtension xsd.AnyType

type MetadataConfigurationOptions 

type MetadataConfigurationOptions struct {
	PTZStatusFilterOptions PTZStatusFilterOptions
	Extension              MetadataConfigurationOptionsExtension
}

type MetadataConfigurationOptionsExtension 

type MetadataConfigurationOptionsExtension struct {
	CompressionType string
	Extension       MetadataConfigurationOptionsExtension2
}

type MetadataConfigurationOptionsExtension2 

type MetadataConfigurationOptionsExtension2 xsd.AnyType

type MoveStatus 

type MoveStatus struct {
	Status string
}

type Mpeg4Configuration 

type Mpeg4Configuration struct {
	GovLength    xsd.Int      `xml:"onvif:GovLength"`
	Mpeg4Profile Mpeg4Profile `xml:"onvif:Mpeg4Profile"`
}

type Mpeg4Options 

type Mpeg4Options struct {
	ResolutionsAvailable   VideoResolution
	GovLengthRange         IntRange
	FrameRateRange         IntRange
	EncodingIntervalRange  IntRange
	Mpeg4ProfilesSupported Mpeg4Profile
}

type Mpeg4Options2 

type Mpeg4Options2 struct {
	Mpeg4Options
	BitrateRange IntRange
}

type Mpeg4Profile 

type Mpeg4Profile xsd.String

type MulticastConfiguration 

type MulticastConfiguration struct {
	Address   IPAddress   `xml:"onvif:Address"`
	Port      int         `xml:"onvif:Port"`
	TTL       int         `xml:"onvif:TTL"`
	AutoStart xsd.Boolean `xml:"onvif:AutoStart"`
}

type NTPInformation 

type NTPInformation struct {
	FromDHCP    xsd.Boolean
	NTPFromDHCP NetworkHost
	NTPManual   NetworkHost
	Extension   NTPInformationExtension
}

type NTPInformationExtension 

type NTPInformationExtension xsd.AnyType

type Name 

type Name xsd.String

type NetworkCapabilities 

type NetworkCapabilities struct {
	IPFilter          xsd.Boolean
	ZeroConfiguration xsd.Boolean
	IPVersion6        xsd.Boolean
	DynDNS            xsd.Boolean
	Extension         NetworkCapabilitiesExtension
}

NetworkCapabilities Check

type NetworkCapabilitiesExtension 

type NetworkCapabilitiesExtension struct {
	Dot11Configuration xsd.Boolean
	Extension          NetworkCapabilitiesExtension2
}

NetworkCapabilitiesExtension Check

type NetworkCapabilitiesExtension2 

type NetworkCapabilitiesExtension2 xsd.AnyType

NetworkCapabilitiesExtension2 Extension2

type NetworkGateway 

type NetworkGateway struct {
	IPv4Address IPv4Address
	IPv6Address IPv6Address
}

type NetworkHost 

type NetworkHost struct {
	Type        NetworkHostType      `xml:"onvif:Type"`
	IPv4Address IPv4Address          `xml:"onvif:IPv4Address"`
	IPv6Address IPv6Address          `xml:"onvif:IPv6Address"`
	DNSname     DNSName              `xml:"onvif:DNSname"`
	Extension   NetworkHostExtension `xml:"onvif:Extension"`
}

type NetworkHostExtension 

type NetworkHostExtension xsd.String

type NetworkHostType 

type NetworkHostType xsd.String

type NetworkInterface 

type NetworkInterface struct {
	DeviceEntity
	Enabled   xsd.Boolean
	Info      NetworkInterfaceInfo
	Link      NetworkInterfaceLink
	IPv4      IPv4NetworkInterface
	IPv6      IPv6NetworkInterface
	Extension NetworkInterfaceExtension
}

type NetworkInterfaceConfigPriority 

type NetworkInterfaceConfigPriority xsd.Integer

TODO: restrictions

type NetworkInterfaceConnectionSetting 

type NetworkInterfaceConnectionSetting struct {
	AutoNegotiation xsd.Boolean `xml:"onvif:AutoNegotiation"`
	Speed           xsd.Int     `xml:"onvif:Speed"`
	Duplex          Duplex      `xml:"onvif:Duplex"`
}

type NetworkInterfaceExtension 

type NetworkInterfaceExtension struct {
	InterfaceType IANA_IfTypes
	Dot3          Dot3Configuration
	Dot11         Dot11Configuration
	Extension     NetworkInterfaceExtension2
}

type NetworkInterfaceExtension2 

type NetworkInterfaceExtension2 xsd.AnyType

type NetworkInterfaceInfo 

type NetworkInterfaceInfo struct {
	Name      xsd.String
	HwAddress HwAddress
	MTU       xsd.Int
}
type NetworkInterfaceLink struct {
	AdminSettings NetworkInterfaceConnectionSetting
	OperSettings  NetworkInterfaceConnectionSetting
	InterfaceType IANA_IfTypes `xml:"IANA-IfTypes"`
}

type NetworkInterfaceSetConfiguration 

type NetworkInterfaceSetConfiguration struct {
	Enabled   xsd.Boolean                               `xml:"onvif:Enabled"`
	Link      NetworkInterfaceConnectionSetting         `xml:"onvif:Link"`
	MTU       xsd.Int                                   `xml:"onvif:MTU"`
	IPv4      IPv4NetworkInterfaceSetConfiguration      `xml:"onvif:IPv4"`
	IPv6      IPv6NetworkInterfaceSetConfiguration      `xml:"onvif:IPv6"`
	Extension NetworkInterfaceSetConfigurationExtension `xml:"onvif:Extension"`
}

type NetworkInterfaceSetConfigurationExtension 

type NetworkInterfaceSetConfigurationExtension struct {
	Dot3      Dot3Configuration                          `xml:"onvif:Dot3"`
	Dot11     Dot11Configuration                         `xml:"onvif:Dot11"`
	Extension NetworkInterfaceSetConfigurationExtension2 `xml:"onvif:Extension"`
}

type NetworkInterfaceSetConfigurationExtension2 

type NetworkInterfaceSetConfigurationExtension2 xsd.AnyType

type NetworkProtocol 

type NetworkProtocol struct {
	Name      NetworkProtocolType      `xml:"onvif:Name"`
	Enabled   xsd.Boolean              `xml:"onvif:Enabled"`
	Port      xsd.Int                  `xml:"onvif:Port"`
	Extension NetworkProtocolExtension `xml:"onvif:Extension"`
}

type NetworkProtocolExtension 

type NetworkProtocolExtension xsd.AnyType

type NetworkProtocolType 

type NetworkProtocolType xsd.String

TODO: enumeration

type NetworkZeroConfiguration 

type NetworkZeroConfiguration struct {
	InterfaceToken ReferenceToken
	Enabled        xsd.Boolean
	Addresses      IPv4Address
	Extension      NetworkZeroConfigurationExtension
}

type NetworkZeroConfigurationExtension 

type NetworkZeroConfigurationExtension struct {
	Additional *NetworkZeroConfiguration
	Extension  NetworkZeroConfigurationExtension2
}

type NetworkZeroConfigurationExtension2 

type NetworkZeroConfigurationExtension2 xsd.AnyType

type NoiseReduction 

type NoiseReduction struct {
	Level float64 `xml:"onvif:Level"`
}

type OSDColor 

type OSDColor struct {
	Transparent int `xml:"Transparent,attr"`

	Color Color `xml:"onvif:Color"`
}

type OSDColorOptions 

type OSDColorOptions struct {
	Color       ColorOptions
	Transparent IntRange
	Extension   OSDColorOptionsExtension
}

type OSDColorOptionsExtension 

type OSDColorOptionsExtension xsd.AnyType

type OSDConfiguration 

type OSDConfiguration struct {
	DeviceEntity                  `xml:"token,attr"`
	VideoSourceConfigurationToken OSDReference              `xml:"onvif:VideoSourceConfigurationToken"`
	Type                          OSDType                   `xml:"onvif:Type"`
	Position                      OSDPosConfiguration       `xml:"onvif:Position"`
	TextString                    OSDTextConfiguration      `xml:"onvif:TextString"`
	Image                         OSDImgConfiguration       `xml:"onvif:Image"`
	Extension                     OSDConfigurationExtension `xml:"onvif:Extension"`
}

type OSDConfigurationExtension 

type OSDConfigurationExtension xsd.AnyType

type OSDConfigurationOptions 

type OSDConfigurationOptions struct {
	MaximumNumberOfOSDs MaximumNumberOfOSDs
	Type                OSDType
	PositionOption      string
	TextOption          OSDTextOptions
	ImageOption         OSDImgOptions
	Extension           OSDConfigurationOptionsExtension
}

type OSDConfigurationOptionsExtension 

type OSDConfigurationOptionsExtension xsd.AnyType

type OSDImgConfiguration 

type OSDImgConfiguration struct {
	ImgPath   xsd.AnyURI                   `xml:"onvif:ImgPath"`
	Extension OSDImgConfigurationExtension `xml:"onvif:Extension"`
}

type OSDImgConfigurationExtension 

type OSDImgConfigurationExtension xsd.AnyType

type OSDImgOptions 

type OSDImgOptions struct {
	FormatsSupported StringAttrList `xml:"FormatsSupported,attr"`
	MaxSize          int            `xml:"MaxSize,attr"`
	MaxWidth         int            `xml:"MaxWidth,attr"`
	MaxHeight        int            `xml:"MaxHeight,attr"`

	ImagePath xsd.AnyURI
	Extension OSDImgOptionsExtension
}

type OSDImgOptionsExtension 

type OSDImgOptionsExtension xsd.AnyType

type OSDPosConfiguration 

type OSDPosConfiguration struct {
	Type      string                       `xml:"onvif:Type"`
	Pos       Vector                       `xml:"onvif:Pos"`
	Extension OSDPosConfigurationExtension `xml:"onvif:Extension"`
}

type OSDPosConfigurationExtension 

type OSDPosConfigurationExtension xsd.AnyType

type OSDReference 

type OSDReference ReferenceToken

type OSDTextConfiguration 

type OSDTextConfiguration struct {
	IsPersistentText xsd.Boolean `xml:"IsPersistentText,attr"`

	Type            xsd.String                    `xml:"onvif:Type"`
	DateFormat      xsd.String                    `xml:"onvif:DateFormat"`
	TimeFormat      xsd.String                    `xml:"onvif:TimeFormat"`
	FontSize        xsd.Int                       `xml:"onvif:FontSize"`
	FontColor       OSDColor                      `xml:"onvif:FontColor"`
	BackgroundColor OSDColor                      `xml:"onvif:BackgroundColor"`
	PlainText       xsd.String                    `xml:"onvif:PlainText"`
	Extension       OSDTextConfigurationExtension `xml:"onvif:Extension"`
}

type OSDTextConfigurationExtension 

type OSDTextConfigurationExtension xsd.AnyType

type OSDTextOptions 

type OSDTextOptions struct {
	Type            string
	FontSizeRange   IntRange
	DateFormat      string
	TimeFormat      string
	FontColor       OSDColorOptions
	BackgroundColor OSDColorOptions
	Extension       OSDTextOptionsExtension
}

type OSDTextOptionsExtension 

type OSDTextOptionsExtension xsd.AnyType

type OSDType 

type OSDType xsd.String

type OnvifVersion 

type OnvifVersion struct {
	Major int
	Minor int
}

type PTControlDirection 

type PTControlDirection struct {
	EFlip     EFlip                       `xml:"onvif:EFlip"`
	Reverse   Reverse                     `xml:"onvif:Reverse"`
	Extension PTControlDirectionExtension `xml:"onvif:Extension"`
}

type PTControlDirectionExtension 

type PTControlDirectionExtension xsd.AnyType

type PTControlDirectionOptions 

type PTControlDirectionOptions struct {
	EFlip     EFlipOptions
	Reverse   ReverseOptions
	Extension PTControlDirectionOptionsExtension
}

type PTControlDirectionOptionsExtension 

type PTControlDirectionOptionsExtension xsd.AnyType

type PTZCapabilities 

type PTZCapabilities struct {
	XAddr xsd.AnyURI
}

type PTZConfiguration 

type PTZConfiguration struct {
	ConfigurationEntity
	MoveRamp                               int                       `xml:"MoveRamp,attr"`
	PresetRamp                             int                       `xml:"PresetRamp,attr"`
	PresetTourRamp                         int                       `xml:"PresetTourRamp,attr"`
	NodeToken                              ReferenceToken            `xml:"NodeToken"`
	DefaultAbsolutePantTiltPositionSpace   xsd.AnyURI                `xml:"DefaultAbsolutePantTiltPositionSpace"`
	DefaultAbsoluteZoomPositionSpace       xsd.AnyURI                `xml:"DefaultAbsoluteZoomPositionSpace"`
	DefaultRelativePanTiltTranslationSpace xsd.AnyURI                `xml:"DefaultRelativePanTiltTranslationSpace"`
	DefaultRelativeZoomTranslationSpace    xsd.AnyURI                `xml:"DefaultRelativeZoomTranslationSpace"`
	DefaultContinuousPanTiltVelocitySpace  xsd.AnyURI                `xml:"DefaultContinuousPanTiltVelocitySpace"`
	DefaultContinuousZoomVelocitySpace     xsd.AnyURI                `xml:"DefaultContinuousZoomVelocitySpace"`
	DefaultPTZSpeed                        PTZSpeed                  `xml:"DefaultPTZSpeed"`
	DefaultPTZTimeout                      xsd.Duration              `xml:"DefaultPTZTimeout"`
	PanTiltLimits                          PanTiltLimits             `xml:"PanTiltLimits"`
	ZoomLimits                             ZoomLimits                `xml:"ZoomLimits"`
	Extension                              PTZConfigurationExtension `xml:"Extension"`
}

type PTZConfigurationExtension 

type PTZConfigurationExtension struct {
	PTControlDirection PTControlDirection         `xml:"onvif:PTControlDirection"`
	Extension          PTZConfigurationExtension2 `xml:"onvif:Extension"`
}

type PTZConfigurationExtension2 

type PTZConfigurationExtension2 xsd.AnyType

type PTZConfigurationOptions 

type PTZConfigurationOptions struct {
	PTZRamps           IntAttrList `xml:"PTZRamps,attr"`
	Spaces             PTZSpaces
	PTZTimeout         DurationRange
	PTControlDirection PTControlDirectionOptions
	Extension          PTZConfigurationOptions2
}

type PTZConfigurationOptions2 

type PTZConfigurationOptions2 xsd.AnyType

type PTZFilter 

type PTZFilter struct {
	Status   bool `xml:"onvif:Status"`
	Position bool `xml:"onvif:Position"`
}

type PTZMoveStatus 

type PTZMoveStatus struct {
	PanTilt MoveStatus
	Zoom    MoveStatus
}

type PTZNode 

type PTZNode struct {
	DeviceEntity
	FixedHomePosition      xsd.Boolean `xml:"FixedHomePosition,attr"`
	GeoMove                xsd.Boolean `xml:"GeoMove,attr"`
	Name                   Name
	SupportedPTZSpaces     PTZSpaces
	MaximumNumberOfPresets int
	HomeSupported          xsd.Boolean
	AuxiliaryCommands      AuxiliaryData
	Extension              PTZNodeExtension
}

type PTZNodeExtension 

type PTZNodeExtension struct {
	SupportedPresetTour PTZPresetTourSupported
	Extension           PTZNodeExtension2
}

type PTZNodeExtension2 

type PTZNodeExtension2 xsd.AnyType

type PTZPreset 

type PTZPreset struct {
	Token       ReferenceToken `xml:"token,attr"`
	Name        Name
	PTZPosition PTZVector
}

type PTZPresetTourDirection 

type PTZPresetTourDirection xsd.String

type PTZPresetTourExtension 

type PTZPresetTourExtension xsd.AnyType

type PTZPresetTourOperation 

type PTZPresetTourOperation xsd.String

type PTZPresetTourOptions 

type PTZPresetTourOptions struct {
	AutoStart         xsd.Boolean
	StartingCondition PTZPresetTourStartingConditionOptions
	TourSpot          PTZPresetTourSpotOptions
}

type PTZPresetTourPresetDetail 

type PTZPresetTourPresetDetail struct {
	PresetToken   ReferenceToken             `xml:"onvif:PresetToken"`
	Home          xsd.Boolean                `xml:"onvif:Home"`
	PTZPosition   PTZVector                  `xml:"onvif:PTZPosition"`
	TypeExtension PTZPresetTourTypeExtension `xml:"onvif:TypeExtension"`
}

type PTZPresetTourPresetDetailOptions 

type PTZPresetTourPresetDetailOptions struct {
	PresetToken          ReferenceToken
	Home                 xsd.Boolean
	PanTiltPositionSpace Space2DDescription
	ZoomPositionSpace    Space1DDescription
	Extension            PTZPresetTourPresetDetailOptionsExtension
}

type PTZPresetTourPresetDetailOptionsExtension 

type PTZPresetTourPresetDetailOptionsExtension xsd.AnyType

type PTZPresetTourSpot 

type PTZPresetTourSpot struct {
	PresetDetail PTZPresetTourPresetDetail  `xml:"onvif:PresetDetail"`
	Speed        PTZSpeed                   `xml:"onvif:Speed"`
	StayTime     xsd.Duration               `xml:"onvif:StayTime"`
	Extension    PTZPresetTourSpotExtension `xml:"onvif:Extension"`
}

type PTZPresetTourSpotExtension 

type PTZPresetTourSpotExtension xsd.AnyType

type PTZPresetTourSpotOptions 

type PTZPresetTourSpotOptions struct {
	PresetDetail PTZPresetTourPresetDetailOptions
	StayTime     DurationRange
}

type PTZPresetTourStartingCondition 

type PTZPresetTourStartingCondition struct {
	RandomPresetOrder xsd.Boolean                             `xml:"RandomPresetOrder,attr"`
	RecurringTime     xsd.Int                                 `xml:"onvif:RecurringTime"`
	RecurringDuration xsd.Duration                            `xml:"onvif:RecurringDuration"`
	Direction         PTZPresetTourDirection                  `xml:"onvif:Direction"`
	Extension         PTZPresetTourStartingConditionExtension `xml:"onvif:Extension"`
}

type PTZPresetTourStartingConditionExtension 

type PTZPresetTourStartingConditionExtension xsd.AnyType

type PTZPresetTourStartingConditionOptions 

type PTZPresetTourStartingConditionOptions struct {
	RecurringTime     IntRange
	RecurringDuration DurationRange
	Direction         PTZPresetTourDirection
	Extension         PTZPresetTourStartingConditionOptionsExtension
}

type PTZPresetTourStartingConditionOptionsExtension 

type PTZPresetTourStartingConditionOptionsExtension xsd.AnyType

type PTZPresetTourState 

type PTZPresetTourState xsd.String

type PTZPresetTourStatus 

type PTZPresetTourStatus struct {
	State           PTZPresetTourState           `xml:"onvif:State"`
	CurrentTourSpot PTZPresetTourSpot            `xml:"onvif:CurrentTourSpot"`
	Extension       PTZPresetTourStatusExtension `xml:"onvif:Extension"`
}

type PTZPresetTourStatusExtension 

type PTZPresetTourStatusExtension xsd.AnyType

type PTZPresetTourSupported 

type PTZPresetTourSupported struct {
	MaximumNumberOfPresetTours int
	PTZPresetTourOperation     PTZPresetTourOperation
	Extension                  PTZPresetTourSupportedExtension
}

type PTZPresetTourSupportedExtension 

type PTZPresetTourSupportedExtension xsd.AnyType

type PTZPresetTourTypeExtension 

type PTZPresetTourTypeExtension xsd.AnyType

type PTZSpaces 

type PTZSpaces struct {
	AbsolutePanTiltPositionSpace    Space2DDescription
	AbsoluteZoomPositionSpace       Space1DDescription
	RelativePanTiltTranslationSpace Space2DDescription
	RelativeZoomTranslationSpace    Space1DDescription
	ContinuousPanTiltVelocitySpace  Space2DDescription
	ContinuousZoomVelocitySpace     Space1DDescription
	PanTiltSpeedSpace               Space1DDescription
	ZoomSpeedSpace                  Space1DDescription
	Extension                       PTZSpacesExtension
}

type PTZSpacesExtension 

type PTZSpacesExtension xsd.AnyType

type PTZSpeed 

type PTZSpeed struct {
	PanTilt Vector2D `xml:"onvif:PanTilt"`
	Zoom    Vector1D `xml:"onvif:Zoom"`
}

type PTZStatus 

type PTZStatus struct {
	Position   PTZVector
	MoveStatus PTZMoveStatus
	Error      string
	UtcTime    xsd.DateTime
}

type PTZStatusFilterOptions 

type PTZStatusFilterOptions struct {
	PanTiltStatusSupported   bool
	ZoomStatusSupported      bool
	PanTiltPositionSupported bool
	ZoomPositionSupported    bool
	Extension                PTZStatusFilterOptionsExtension
}

type PTZStatusFilterOptionsExtension 

type PTZStatusFilterOptionsExtension xsd.AnyType

type PTZVector 

type PTZVector struct {
	PanTilt Vector2D `xml:"onvif:PanTilt"`
	Zoom    Vector1D `xml:"onvif:Zoom"`
}

type PanTiltLimits 

type PanTiltLimits struct {
	Range Space2DDescription `xml:"Range"`
}

type PrefixedIPv4Address 

type PrefixedIPv4Address struct {
	Address      IPv4Address `xml:"onvif:Address"`
	PrefixLength xsd.Int     `xml:"onvif:PrefixLength"`
}

optional, unbounded

type PrefixedIPv6Address 

type PrefixedIPv6Address struct {
	Address      IPv6Address `xml:"onvif:Address"`
	PrefixLength xsd.Int     `xml:"onvif:PrefixLength"`
}

type PresetTour 

type PresetTour struct {
	Token             ReferenceToken                 `xml:"token,attr"`
	Name              Name                           `xml:"onvif:Name"`
	Status            PTZPresetTourStatus            `xml:"onvif:Status"`
	AutoStart         xsd.Boolean                    `xml:"onvif:AutoStart"`
	StartingCondition PTZPresetTourStartingCondition `xml:"onvif:StartingCondition"`
	TourSpot          PTZPresetTourSpot              `xml:"onvif:TourSpot"`
	Extension         PTZPresetTourExtension         `xml:"onvif:Extension"`
}

type Profile 

type Profile struct {
	Token                       ReferenceToken `xml:"token,attr"`
	Fixed                       bool           `xml:"fixed,attr"`
	Name                        Name
	VideoSourceConfiguration    VideoSourceConfiguration
	AudioSourceConfiguration    AudioSourceConfiguration
	VideoEncoderConfiguration   VideoEncoderConfiguration
	AudioEncoderConfiguration   AudioEncoderConfiguration
	VideoAnalyticsConfiguration VideoAnalyticsConfiguration
	PTZConfiguration            PTZConfiguration
	MetadataConfiguration       MetadataConfiguration
	Extension                   ProfileExtension
}

type ProfileCapabilities 

type ProfileCapabilities struct {
	MaximumNumberOfProfiles int
}

type ProfileExtension 

type ProfileExtension struct {
	AudioOutputConfiguration  AudioOutputConfiguration
	AudioDecoderConfiguration AudioDecoderConfiguration
	Extension                 ProfileExtension2
}

type ProfileExtension2 

type ProfileExtension2 xsd.AnyType

type RealTimeStreamingCapabilities 

type RealTimeStreamingCapabilities struct {
	RTPMulticast xsd.Boolean
	RTP_TCP      xsd.Boolean
	RTP_RTSP_TCP xsd.Boolean
	Extension    RealTimeStreamingCapabilitiesExtension
}

type RealTimeStreamingCapabilitiesExtension 

type RealTimeStreamingCapabilitiesExtension xsd.AnyType

type ReceiverCapabilities 

type ReceiverCapabilities struct {
	XAddr                xsd.AnyURI
	RTP_Multicast        xsd.Boolean
	RTP_TCP              xsd.Boolean
	RTP_RTSP_TCP         xsd.Boolean
	SupportedReceivers   int
	MaximumRTSPURILength int
}

type RecordingCapabilities 

type RecordingCapabilities struct {
	XAddr              xsd.AnyURI
	ReceiverSource     xsd.Boolean
	MediaProfileSource xsd.Boolean
	DynamicRecordings  xsd.Boolean
	DynamicTracks      xsd.Boolean
	MaxStringLength    int
}

type Rectangle 

type Rectangle struct {
	Bottom float64 `xml:"bottom,attr"`
	Top    float64 `xml:"top,attr"`
	Right  float64 `xml:"right,attr"`
	Left   float64 `xml:"left,attr"`
}

type ReferenceToken 

type ReferenceToken xsd.String

type RelativeFocus 

type RelativeFocus struct {
	Distance xsd.Float `xml:"onvif:Distance"`
	Speed    xsd.Float `xml:"onvif:Speed"`
}

type RelayIdleState 

type RelayIdleState xsd.String

TODO:enumeration

type RelayLogicalState 

type RelayLogicalState xsd.String

TODO: enumeration

type RelayMode 

type RelayMode xsd.String

TODO: enumeration

type RelayOutput 

type RelayOutput struct {
	DeviceEntity
	Properties RelayOutputSettings
}

type RelayOutputSettings 

type RelayOutputSettings struct {
	Mode      RelayMode      `xml:"onvif:Mode"`
	DelayTime xsd.Duration   `xml:"onvif:DelayTime"`
	IdleState RelayIdleState `xml:"onvif:IdleState"`
}

type RemoteUser 

type RemoteUser struct {
	Username           string      `xml:"onvif:Username"`
	Password           string      `xml:"onvif:Password"`
	UseDerivedPassword xsd.Boolean `xml:"onvif:UseDerivedPassword"`
}

type ReplayCapabilities 

type ReplayCapabilities struct {
	XAddr xsd.AnyURI
}

type Reverse 

type Reverse struct {
	Mode ReverseMode `xml:"onvif:Mode"`
}

type ReverseMode 

type ReverseMode xsd.String

type ReverseOptions 

type ReverseOptions struct {
	Mode      ReverseMode
	Extension ReverseOptionsExtension
}

type ReverseOptionsExtension 

type ReverseOptionsExtension xsd.AnyType

type Rotate 

type Rotate struct {
	Mode      RotateMode      `xml:"onvif:Mode"`
	Degree    xsd.Int         `xml:"onvif:Degree"`
	Extension RotateExtension `xml:"onvif:Extension"`
}

type RotateExtension 

type RotateExtension xsd.AnyType

type RotateMode 

type RotateMode xsd.String

type RotateOptions 

type RotateOptions struct {
	Mode       RotateMode
	DegreeList IntList
	Extension  RotateOptionsExtension
}

type RotateOptionsExtension 

type RotateOptionsExtension xsd.AnyType

type RuleEngineConfiguration 

type RuleEngineConfiguration struct {
	Rule      Config                           `xml:"onvif:Rule"`
	Extension RuleEngineConfigurationExtension `xml:"onvif:Extension"`
}

type RuleEngineConfigurationExtension 

type RuleEngineConfigurationExtension xsd.AnyType

type SceneOrientation 

type SceneOrientation struct {
	Mode        SceneOrientationMode `xml:"onvif:Mode"`
	Orientation xsd.String           `xml:"onvif:Orientation"`
}

type SceneOrientationMode 

type SceneOrientationMode xsd.String

type Scope 

type Scope struct {
	ScopeDef  ScopeDefinition
	ScopeItem xsd.AnyURI
}

type ScopeDefinition 

type ScopeDefinition xsd.String

type SearchCapabilities 

type SearchCapabilities struct {
	XAddr          xsd.AnyURI
	MetadataSearch xsd.Boolean
}

type SecurityCapabilities 

type SecurityCapabilities struct {
	TLS1_1               xsd.Boolean
	TLS1_2               xsd.Boolean
	OnboardKeyGeneration xsd.Boolean
	AccessPolicyConfig   xsd.Boolean
	X_509Token           xsd.Boolean
	SAMLToken            xsd.Boolean
	KerberosToken        xsd.Boolean
	RELToken             xsd.Boolean
	Extension            SecurityCapabilitiesExtension
}

type SecurityCapabilitiesExtension 

type SecurityCapabilitiesExtension struct {
	TLS1_0    xsd.Boolean
	Extension SecurityCapabilitiesExtension2
}

type SecurityCapabilitiesExtension2 

type SecurityCapabilitiesExtension2 struct {
	Dot1X              xsd.Boolean
	SupportedEAPMethod int
	RemoteUserHandling xsd.Boolean
}

type SetDateTimeType 

type SetDateTimeType xsd.String

type SimpleItem 

type SimpleItem struct {
	Name  string            `xml:"Name,attr"`
	Value xsd.AnySimpleType `xml:"Value,attr"`
}

type Space1DDescription 

type Space1DDescription struct {
	URI    xsd.AnyURI `xml:"URI"`
	XRange FloatRange `xml:"XRange"`
}

type Space2DDescription 

type Space2DDescription struct {
	URI    xsd.AnyURI `xml:"URI"`
	XRange FloatRange `xml:"XRange"`
	YRange FloatRange `xml:"YRange"`
}

type StreamSetup 

type StreamSetup struct {
	Stream    StreamType `xml:"onvif:Stream"`
	Transport Transport  `xml:"onvif:Transport"`
}

type StreamType 

type StreamType xsd.String

type StringAttrList 

type StringAttrList struct {
	AttrList []string
}

type SubscriptionPolicy 

type SubscriptionPolicy xsd.AnyType

type SupportInformation 

type SupportInformation struct {
	Binary AttachmentData
	String string
}

type SystemCapabilities 

type SystemCapabilities struct {
	DiscoveryResolve  xsd.Boolean
	DiscoveryBye      xsd.Boolean
	RemoteDiscovery   xsd.Boolean
	SystemBackup      xsd.Boolean
	SystemLogging     xsd.Boolean
	FirmwareUpgrade   xsd.Boolean
	SupportedVersions OnvifVersion
	Extension         SystemCapabilitiesExtension
}

SystemCapabilities check

type SystemCapabilitiesExtension 

type SystemCapabilitiesExtension struct {
	HttpFirmwareUpgrade    xsd.Boolean
	HttpSystemBackup       xsd.Boolean
	HttpSystemLogging      xsd.Boolean
	HttpSupportInformation xsd.Boolean
	Extension              SystemCapabilitiesExtension2
}

type SystemCapabilitiesExtension2 

type SystemCapabilitiesExtension2 xsd.AnyType

type SystemDateTime 

type SystemDateTime struct {
	DateTimeType    SetDateTimeType
	DaylightSavings xsd.Boolean
	TimeZone        TimeZone
	UTCDateTime     xsd.DateTime
	LocalDateTime   xsd.DateTime
	Extension       SystemDateTimeExtension
}

type SystemDateTimeExtension 

type SystemDateTimeExtension xsd.AnyType

type SystemLog 

type SystemLog struct {
	Binary AttachmentData
	String string
}

type SystemLogType 

type SystemLogType xsd.String

type SystemLogUri 

type SystemLogUri struct {
	Type SystemLogType
	Uri  xsd.AnyURI
}

type SystemLogUriList 

type SystemLogUriList struct {
	SystemLog SystemLogUri
}

type TLSConfiguration 

type TLSConfiguration struct {
	CertificateID xsd.Token `xml:"onvif:CertificateID,omitempty"`
}

type Time 

type Time struct {
	Hour   xsd.Int `xml:"onvif:Hour"`
	Minute xsd.Int `xml:"onvif:Minute"`
	Second xsd.Int `xml:"onvif:Second"`
}

type TimeZone 

type TimeZone struct {
	TZ xsd.Token `xml:"onvif:TZ"`
}

type ToneCompensation 

type ToneCompensation struct {
	Mode      string                    `xml:"onvif:Mode"`
	Level     float64                   `xml:"onvif:Level"`
	Extension ToneCompensationExtension `xml:"onvif:Extension"`
}

type ToneCompensationExtension 

type ToneCompensationExtension xsd.AnyType

type Transport 

type Transport struct {
	Protocol TransportProtocol `xml:"onvif:Protocol"`
	Tunnel   *Transport        `xml:"onvif:Tunnel"`
}

type TransportProtocol 

type TransportProtocol xsd.String

enum

type User 

type User struct {
	Username  string        `xml:"onvif:Username"`
	Password  string        `xml:"onvif:Password"`
	UserLevel UserLevel     `xml:"onvif:UserLevel"`
	Extension UserExtension `xml:"onvif:Extension"`
}

type UserExtension 

type UserExtension xsd.String

type UserLevel 

type UserLevel xsd.String

type Vector 

type Vector struct {
	X float64 `xml:"x,attr"`
	Y float64 `xml:"y,attr"`
}

type Vector1D 

type Vector1D struct {
	X     float64    `xml:"x,attr"`
	Space xsd.AnyURI `xml:"space,attr"`
}

type Vector2D 

type Vector2D struct {
	X     float64    `xml:"x,attr"`
	Y     float64    `xml:"y,attr"`
	Space xsd.AnyURI `xml:"space,attr"`
}

type VideoAnalyticsConfiguration 

type VideoAnalyticsConfiguration struct {
	ConfigurationEntity
	AnalyticsEngineConfiguration AnalyticsEngineConfiguration `xml:"onvif:AnalyticsEngineConfiguration"`
	RuleEngineConfiguration      RuleEngineConfiguration      `xml:"onvif:RuleEngineConfiguration"`
}

type VideoEncoderConfiguration 

type VideoEncoderConfiguration struct {
	ConfigurationEntity
	Encoding       VideoEncoding          `xml:"onvif:Encoding"`
	Resolution     VideoResolution        `xml:"onvif:Resolution"`
	Quality        float64                `xml:"onvif:Quality"`
	RateControl    VideoRateControl       `xml:"onvif:RateControl"`
	MPEG4          Mpeg4Configuration     `xml:"onvif:MPEG4"`
	H264           H264Configuration      `xml:"onvif:H264"`
	Multicast      MulticastConfiguration `xml:"onvif:Multicast"`
	SessionTimeout xsd.Duration           `xml:"onvif:SessionTimeout"`
}

type VideoEncoderConfigurationOptions 

type VideoEncoderConfigurationOptions struct {
	QualityRange IntRange
	JPEG         JpegOptions
	MPEG4        Mpeg4Options
	H264         H264Options
	Extension    VideoEncoderOptionsExtension
}

type VideoEncoderOptionsExtension 

type VideoEncoderOptionsExtension struct {
	JPEG      JpegOptions2
	MPEG4     Mpeg4Options2
	H264      H264Options2
	Extension VideoEncoderOptionsExtension2
}

type VideoEncoderOptionsExtension2 

type VideoEncoderOptionsExtension2 xsd.AnyType

type VideoEncoding 

type VideoEncoding xsd.String

type VideoRateControl 

type VideoRateControl struct {
	FrameRateLimit   xsd.Int `xml:"onvif:FrameRateLimit"`
	EncodingInterval xsd.Int `xml:"onvif:EncodingInterval"`
	BitrateLimit     xsd.Int `xml:"onvif:BitrateLimit"`
}

type VideoResolution 

type VideoResolution struct {
	Width  xsd.Int `xml:"onvif:Width"`
	Height xsd.Int `xml:"onvif:Height"`
}

type VideoSource 

type VideoSource struct {
	DeviceEntity
	Framerate  float64
	Resolution VideoResolution
	Imaging    ImagingSettings
	Extension  VideoSourceExtension
}

type VideoSourceConfiguration 

type VideoSourceConfiguration struct {
	ConfigurationEntity
	ViewMode    string                            `xml:"ViewMode,attr"`
	SourceToken ReferenceToken                    `xml:"onvif:SourceToken"`
	Bounds      IntRectangle                      `xml:"onvif:Bounds"`
	Extension   VideoSourceConfigurationExtension `xml:"onvif:Extension"`
}

type VideoSourceConfigurationExtension 

type VideoSourceConfigurationExtension struct {
	Rotate    Rotate                             `xml:"onvif:Rotate"`
	Extension VideoSourceConfigurationExtension2 `xml:"onvif:Extension"`
}

type VideoSourceConfigurationExtension2 

type VideoSourceConfigurationExtension2 struct {
	LensDescription  LensDescription  `xml:"onvif:LensDescription"`
	SceneOrientation SceneOrientation `xml:"onvif:SceneOrientation"`
}

type VideoSourceConfigurationOptions 

type VideoSourceConfigurationOptions struct {
	MaximumNumberOfProfiles    int `xml:"MaximumNumberOfProfiles,attr"`
	BoundsRange                IntRectangleRange
	VideoSourceTokensAvailable ReferenceToken
	Extension                  VideoSourceConfigurationOptionsExtension
}

type VideoSourceConfigurationOptionsExtension 

type VideoSourceConfigurationOptionsExtension struct {
	Rotate    RotateOptions
	Extension VideoSourceConfigurationOptionsExtension2
}

type VideoSourceConfigurationOptionsExtension2 

type VideoSourceConfigurationOptionsExtension2 struct {
	SceneOrientationMode SceneOrientationMode
}

type VideoSourceExtension 

type VideoSourceExtension struct {
	Imaging   ImagingSettings20
	Extension VideoSourceExtension2
}

type VideoSourceExtension2 

type VideoSourceExtension2 xsd.AnyType

type VideoSourceMode 

type VideoSourceMode struct {
	Token         ReferenceToken `xml:"token,attr"`
	Enabled       bool           `xml:"Enabled,attr"`
	MaxFramerate  float64
	MaxResolution VideoResolution
	Encodings     EncodingTypes
	Reboot        bool
	Description   Description
	Extension     VideoSourceModeExtension
}

type VideoSourceModeExtension 

type VideoSourceModeExtension xsd.AnyType

type WhiteBalance 

type WhiteBalance struct {
	Mode   WhiteBalanceMode
	CrGain float64
	CbGain float64
}

type WhiteBalance20 

type WhiteBalance20 struct {
	Mode      WhiteBalanceMode        `xml:"onvif:Mode"`
	CrGain    float64                 `xml:"onvif:CrGain"`
	CbGain    float64                 `xml:"onvif:CbGain"`
	Extension WhiteBalance20Extension `xml:"onvif:Extension"`
}

type WhiteBalance20Extension 

type WhiteBalance20Extension xsd.AnyType

type WhiteBalanceMode 

type WhiteBalanceMode xsd.String

type WideDynamicMode 

type WideDynamicMode xsd.String

type WideDynamicRange 

type WideDynamicRange struct {
	Mode  WideDynamicMode `xml:"onvif:Mode"`
	Level float64         `xml:"onvif:Level"`
}

type WideDynamicRange20 

type WideDynamicRange20 struct {
	Mode  WideDynamicMode `xml:"onvif:Mode"`
	Level float64         `xml:"onvif:Level"`
}

type ZoomLimits 

type ZoomLimits struct {
	Range Space1DDescription `xml:"Range"`
}

Notes

Bugs

  • Enum types implemented as simple string

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.