package onvif

import "time"

// DeviceInformation contains basic device information
type DeviceInformation struct {
	Manufacturer    string
	Model           string
	FirmwareVersion string
	SerialNumber    string
	HardwareID      string
}

// Capabilities represents the device capabilities
type Capabilities struct {
	Analytics *AnalyticsCapabilities
	Device    *DeviceCapabilities
	Events    *EventCapabilities
	Imaging   *ImagingCapabilities
	Media     *MediaCapabilities
	PTZ       *PTZCapabilities
	Extension *CapabilitiesExtension
}

// AnalyticsCapabilities represents analytics service capabilities
type AnalyticsCapabilities struct {
	XAddr                  string
	RuleSupport            bool
	AnalyticsModuleSupport bool
}

// DeviceCapabilities represents device service capabilities
type DeviceCapabilities struct {
	XAddr    string
	Network  *NetworkCapabilities
	System   *SystemCapabilities
	IO       *IOCapabilities
	Security *SecurityCapabilities
}

// EventCapabilities represents event service capabilities
type EventCapabilities struct {
	XAddr                         string
	WSSubscriptionPolicySupport   bool
	WSPullPointSupport            bool
	WSPausableSubscriptionSupport bool
}

// ImagingCapabilities represents imaging service capabilities
type ImagingCapabilities struct {
	XAddr string
}

// MediaCapabilities represents media service capabilities
type MediaCapabilities struct {
	XAddr                 string
	StreamingCapabilities *StreamingCapabilities
}

// PTZCapabilities represents PTZ service capabilities
type PTZCapabilities struct {
	XAddr string
}

// NetworkCapabilities represents network capabilities
type NetworkCapabilities struct {
	IPFilter          bool
	ZeroConfiguration bool
	IPVersion6        bool
	DynDNS            bool
	Extension         *NetworkCapabilitiesExtension
}

// SystemCapabilities represents system capabilities
type SystemCapabilities struct {
	DiscoveryResolve  bool
	DiscoveryBye      bool
	RemoteDiscovery   bool
	SystemBackup      bool
	SystemLogging     bool
	FirmwareUpgrade   bool
	SupportedVersions []string
	Extension         *SystemCapabilitiesExtension
}

// IOCapabilities represents I/O capabilities
type IOCapabilities struct {
	InputConnectors int
	RelayOutputs    int
	Extension       *IOCapabilitiesExtension
}

// SecurityCapabilities represents security capabilities
type SecurityCapabilities struct {
	TLS11                bool
	TLS12                bool
	OnboardKeyGeneration bool
	AccessPolicyConfig   bool
	X509Token            bool
	SAMLToken            bool
	KerberosToken        bool
	RELToken             bool
	Extension            *SecurityCapabilitiesExtension
}

// StreamingCapabilities represents streaming capabilities
type StreamingCapabilities struct {
	RTPMulticast bool
	RTP_TCP      bool
	RTP_RTSP_TCP bool
	Extension    *StreamingCapabilitiesExtension
}

// Extension types
type CapabilitiesExtension struct{}
type NetworkCapabilitiesExtension struct{}
type SystemCapabilitiesExtension struct{}
type IOCapabilitiesExtension struct{}
type SecurityCapabilitiesExtension struct{}
type StreamingCapabilitiesExtension struct{}

// Profile represents a media profile
type Profile struct {
	Token                     string
	Name                      string
	VideoSourceConfiguration  *VideoSourceConfiguration
	AudioSourceConfiguration  *AudioSourceConfiguration
	VideoEncoderConfiguration *VideoEncoderConfiguration
	AudioEncoderConfiguration *AudioEncoderConfiguration
	PTZConfiguration          *PTZConfiguration
	MetadataConfiguration     *MetadataConfiguration
	Extension                 *ProfileExtension
}

// VideoSourceConfiguration represents video source configuration
type VideoSourceConfiguration struct {
	Token       string
	Name        string
	UseCount    int
	SourceToken string
	Bounds      *IntRectangle
}

// AudioSourceConfiguration represents audio source configuration
type AudioSourceConfiguration struct {
	Token       string
	Name        string
	UseCount    int
	SourceToken string
}

// VideoEncoderConfiguration represents video encoder configuration
type VideoEncoderConfiguration struct {
	Token          string
	Name           string
	UseCount       int
	Encoding       string // JPEG, MPEG4, H264
	Resolution     *VideoResolution
	Quality        float64
	RateControl    *VideoRateControl
	MPEG4          *MPEG4Configuration
	H264           *H264Configuration
	Multicast      *MulticastConfiguration
	SessionTimeout time.Duration
}

// AudioEncoderConfiguration represents audio encoder configuration
type AudioEncoderConfiguration struct {
	Token          string
	Name           string
	UseCount       int
	Encoding       string // G711, G726, AAC
	Bitrate        int
	SampleRate     int
	Multicast      *MulticastConfiguration
	SessionTimeout time.Duration
}

// PTZConfiguration represents PTZ configuration
type PTZConfiguration struct {
	Token                                  string
	Name                                   string
	UseCount                               int
	NodeToken                              string
	DefaultAbsolutePantTiltPositionSpace   string
	DefaultAbsoluteZoomPositionSpace       string
	DefaultRelativePanTiltTranslationSpace string
	DefaultRelativeZoomTranslationSpace    string
	DefaultContinuousPanTiltVelocitySpace  string
	DefaultContinuousZoomVelocitySpace     string
	DefaultPTZSpeed                        *PTZSpeed
	DefaultPTZTimeout                      time.Duration
	PanTiltLimits                          *PanTiltLimits
	ZoomLimits                             *ZoomLimits
}

// MetadataConfiguration represents metadata configuration
type MetadataConfiguration struct {
	Token          string
	Name           string
	UseCount       int
	PTZStatus      *PTZFilter
	Events         *EventSubscription
	Analytics      bool
	Multicast      *MulticastConfiguration
	SessionTimeout time.Duration
}

// VideoResolution represents video resolution
type VideoResolution struct {
	Width  int
	Height int
}

// VideoRateControl represents video rate control
type VideoRateControl struct {
	FrameRateLimit   int
	EncodingInterval int
	BitrateLimit     int
}

// MPEG4Configuration represents MPEG4 configuration
type MPEG4Configuration struct {
	GovLength    int
	MPEG4Profile string
}

// H264Configuration represents H264 configuration
type H264Configuration struct {
	GovLength   int
	H264Profile string
}

// MulticastConfiguration represents multicast configuration
type MulticastConfiguration struct {
	Address   *IPAddress
	Port      int
	TTL       int
	AutoStart bool
}

// IPAddress represents an IP address
type IPAddress struct {
	Type        string // IPv4 or IPv6
	Address     string
	IPv4Address string
	IPv6Address string
}

// IntRectangle represents a rectangle with integer coordinates
type IntRectangle struct {
	X      int
	Y      int
	Width  int
	Height int
}

// PTZSpeed represents PTZ speed
type PTZSpeed struct {
	PanTilt *Vector2D
	Zoom    *Vector1D
}

// Vector2D represents a 2D vector
type Vector2D struct {
	X     float64
	Y     float64
	Space string
}

// Vector1D represents a 1D vector
type Vector1D struct {
	X     float64
	Space string
}

// PanTiltLimits represents pan/tilt limits
type PanTiltLimits struct {
	Range *Space2DDescription
}

// ZoomLimits represents zoom limits
type ZoomLimits struct {
	Range *Space1DDescription
}

// Space2DDescription represents 2D space description
type Space2DDescription struct {
	URI    string
	XRange *FloatRange
	YRange *FloatRange
}

// Space1DDescription represents 1D space description
type Space1DDescription struct {
	URI    string
	XRange *FloatRange
}

// FloatRange represents a float range
type FloatRange struct {
	Min float64
	Max float64
}

// PTZFilter represents PTZ filter
type PTZFilter struct {
	Status   bool
	Position bool
}

// EventSubscription represents event subscription
type EventSubscription struct {
	Filter *FilterType
}

// FilterType represents filter type
type FilterType struct {
	// Simplified for now
}

// ProfileExtension represents profile extension
type ProfileExtension struct{}

// StreamSetup represents stream setup parameters
type StreamSetup struct {
	Stream    string // RTP-Unicast, RTP-Multicast
	Transport *Transport
}

// Transport represents transport parameters
type Transport struct {
	Protocol string // UDP, TCP, RTSP, HTTP
	Tunnel   *Tunnel
}

// Tunnel represents tunnel parameters
type Tunnel struct{}

// MediaURI represents a media URI
type MediaURI struct {
	URI                 string
	InvalidAfterConnect bool
	InvalidAfterReboot  bool
	Timeout             time.Duration
}

// PTZStatus represents PTZ status
type PTZStatus struct {
	Position   *PTZVector
	MoveStatus *PTZMoveStatus
	Error      string
	UTCTime    time.Time
}

// PTZVector represents PTZ position
type PTZVector struct {
	PanTilt *Vector2D
	Zoom    *Vector1D
}

// PTZMoveStatus represents PTZ movement status
type PTZMoveStatus struct {
	PanTilt string // IDLE, MOVING, UNKNOWN
	Zoom    string // IDLE, MOVING, UNKNOWN
}

// PTZPreset represents a PTZ preset
type PTZPreset struct {
	Token       string
	Name        string
	PTZPosition *PTZVector
}

// ImagingSettings represents imaging settings
type ImagingSettings struct {
	BacklightCompensation *BacklightCompensation
	Brightness            *float64
	ColorSaturation       *float64
	Contrast              *float64
	Exposure              *Exposure
	Focus                 *FocusConfiguration
	IrCutFilter           *string
	Sharpness             *float64
	WideDynamicRange      *WideDynamicRange
	WhiteBalance          *WhiteBalance
	Extension             *ImagingSettingsExtension
}

// BacklightCompensation represents backlight compensation
type BacklightCompensation struct {
	Mode  string // OFF, ON
	Level float64
}

// Exposure represents exposure settings
type Exposure struct {
	Mode            string // AUTO, MANUAL
	Priority        string // LowNoise, FrameRate
	MinExposureTime float64
	MaxExposureTime float64
	MinGain         float64
	MaxGain         float64
	MinIris         float64
	MaxIris         float64
	ExposureTime    float64
	Gain            float64
	Iris            float64
}

// FocusConfiguration represents focus configuration
type FocusConfiguration struct {
	AutoFocusMode string // AUTO, MANUAL
	DefaultSpeed  float64
	NearLimit     float64
	FarLimit      float64
}

// WideDynamicRange represents WDR settings
type WideDynamicRange struct {
	Mode  string // OFF, ON
	Level float64
}

// WhiteBalance represents white balance settings
type WhiteBalance struct {
	Mode   string // AUTO, MANUAL
	CrGain float64
	CbGain float64
}

// ImagingSettingsExtension represents imaging settings extension
type ImagingSettingsExtension struct{}

// HostnameInformation represents hostname configuration
type HostnameInformation struct {
	FromDHCP bool
	Name     string
}

// DNSInformation represents DNS configuration
type DNSInformation struct {
	FromDHCP     bool
	SearchDomain []string
	DNSFromDHCP  []IPAddress
	DNSManual    []IPAddress
}

// NTPInformation represents NTP configuration
type NTPInformation struct {
	FromDHCP    bool
	NTPFromDHCP []NetworkHost
	NTPManual   []NetworkHost
}

// NetworkHost represents a network host
type NetworkHost struct {
	Type        string // IPv4, IPv6, DNS
	IPv4Address string
	IPv6Address string
	DNSname     string
}

// NetworkInterface represents a network interface
type NetworkInterface struct {
	Token   string
	Enabled bool
	Info    NetworkInterfaceInfo
	IPv4    *IPv4NetworkInterface
	IPv6    *IPv6NetworkInterface
}

// NetworkInterfaceInfo represents network interface info
type NetworkInterfaceInfo struct {
	Name      string
	HwAddress string
	MTU       int
}

// IPv4NetworkInterface represents IPv4 configuration
type IPv4NetworkInterface struct {
	Enabled bool
	Config  IPv4Configuration
}

// IPv6NetworkInterface represents IPv6 configuration
type IPv6NetworkInterface struct {
	Enabled bool
	Config  IPv6Configuration
}

// IPv4Configuration represents IPv4 configuration
type IPv4Configuration struct {
	Manual []PrefixedIPv4Address
	DHCP   bool
}

// IPv6Configuration represents IPv6 configuration
type IPv6Configuration struct {
	Manual []PrefixedIPv6Address
	DHCP   bool
}

// PrefixedIPv4Address represents an IPv4 address with prefix
type PrefixedIPv4Address struct {
	Address      string
	PrefixLength int
}

// PrefixedIPv6Address represents an IPv6 address with prefix
type PrefixedIPv6Address struct {
	Address      string
	PrefixLength int
}

// Scope represents a device scope
type Scope struct {
	ScopeDef  string
	ScopeItem string
}

// User represents a user account
type User struct {
	Username  string
	Password  string
	UserLevel string // Administrator, Operator, User
}

// VideoSource represents a video source
type VideoSource struct {
	Token      string
	Framerate  float64
	Resolution *VideoResolution
	Imaging    *ImagingSettings
}

// AudioSource represents an audio source
type AudioSource struct {
	Token    string
	Channels int
}

// AudioOutput represents an audio output
type AudioOutput struct {
	Token string
}

// ImagingOptions represents available imaging options
type ImagingOptions struct {
	BacklightCompensation *BacklightCompensationOptions
	Brightness            *FloatRange
	ColorSaturation       *FloatRange
	Contrast              *FloatRange
	Exposure              *ExposureOptions
	Focus                 *FocusOptions
	IrCutFilterModes      []string
	Sharpness             *FloatRange
	WideDynamicRange      *WideDynamicRangeOptions
	WhiteBalance          *WhiteBalanceOptions
}

// BacklightCompensationOptions represents backlight compensation options
type BacklightCompensationOptions struct {
	Mode  []string
	Level *FloatRange
}

// ExposureOptions represents exposure options
type ExposureOptions struct {
	Mode            []string
	Priority        []string
	MinExposureTime *FloatRange
	MaxExposureTime *FloatRange
	MinGain         *FloatRange
	MaxGain         *FloatRange
	MinIris         *FloatRange
	MaxIris         *FloatRange
	ExposureTime    *FloatRange
	Gain            *FloatRange
	Iris            *FloatRange
}

// FocusOptions represents focus options
type FocusOptions struct {
	AutoFocusModes []string
	DefaultSpeed   *FloatRange
	NearLimit      *FloatRange
	FarLimit       *FloatRange
}

// WideDynamicRangeOptions represents WDR options
type WideDynamicRangeOptions struct {
	Mode  []string
	Level *FloatRange
}

// WhiteBalanceOptions represents white balance options
type WhiteBalanceOptions struct {
	Mode   []string
	YrGain *FloatRange
	YbGain *FloatRange
}

// MoveOptions represents imaging move options
type MoveOptions struct {
	Absolute   *AbsoluteFocusOptions
	Relative   *RelativeFocusOptions
	Continuous *ContinuousFocusOptions
}

// AbsoluteFocusOptions represents absolute focus options
type AbsoluteFocusOptions struct {
	Position FloatRange
	Speed    FloatRange
}

// RelativeFocusOptions represents relative focus options
type RelativeFocusOptions struct {
	Distance FloatRange
	Speed    FloatRange
}

// ContinuousFocusOptions represents continuous focus options
type ContinuousFocusOptions struct {
	Speed FloatRange
}

// ImagingStatus represents imaging status
type ImagingStatus struct {
	FocusStatus *FocusStatus
}

// FocusStatus represents focus status
type FocusStatus struct {
	Position   float64
	MoveStatus string
	Error      string
}

// Service represents an ONVIF service
type Service struct {
	Namespace    string
	XAddr        string
	Capabilities interface{}
	Version      OnvifVersion
}

// OnvifVersion represents ONVIF version
type OnvifVersion struct {
	Major int
	Minor int
}

// DeviceServiceCapabilities represents device service capabilities
type DeviceServiceCapabilities struct {
	Network  *NetworkCapabilities
	Security *SecurityCapabilities
	System   *SystemCapabilities
	Misc     *MiscCapabilities
}

// MiscCapabilities represents miscellaneous capabilities
type MiscCapabilities struct {
	AuxiliaryCommands []string
}

// DiscoveryMode represents discovery mode
type DiscoveryMode string

const (
	DiscoveryModeDiscoverable    DiscoveryMode = "Discoverable"
	DiscoveryModeNonDiscoverable DiscoveryMode = "NonDiscoverable"
)

// NetworkProtocol represents network protocol configuration
type NetworkProtocol struct {
	Name    NetworkProtocolType
	Enabled bool
	Port    []int
}

// NetworkProtocolType represents protocol type
type NetworkProtocolType string

const (
	NetworkProtocolHTTP  NetworkProtocolType = "HTTP"
	NetworkProtocolHTTPS NetworkProtocolType = "HTTPS"
	NetworkProtocolRTSP  NetworkProtocolType = "RTSP"
)

// NetworkGateway represents default gateway
type NetworkGateway struct {
	IPv4Address []string
	IPv6Address []string
}

// SystemDateTime represents system date and time
type SystemDateTime struct {
	DateTimeType    SetDateTimeType
	DaylightSavings bool
	TimeZone        *TimeZone
	UTCDateTime     *DateTime
	LocalDateTime   *DateTime
}

// SetDateTimeType represents date/time set method
type SetDateTimeType string

const (
	SetDateTimeManual SetDateTimeType = "Manual"
	SetDateTimeNTP    SetDateTimeType = "NTP"
)

// TimeZone represents timezone
type TimeZone struct {
	TZ string // POSIX format
}

// DateTime represents date and time
type DateTime struct {
	Time Time
	Date Date
}

// Time represents time
type Time struct {
	Hour   int
	Minute int
	Second int
}

// Date represents date
type Date struct {
	Year  int
	Month int
	Day   int
}

// SystemLogType represents system log type
type SystemLogType string

const (
	SystemLogTypeSystem SystemLogType = "System"
	SystemLogTypeAccess SystemLogType = "Access"
)

// SystemLog represents system log data
type SystemLog struct {
	Binary *AttachmentData
	String string
}

// AttachmentData represents attachment/binary data
type AttachmentData struct {
	ContentType string
	Include     *Include
}

// Include represents XOP include
type Include struct {
	Href string
}

// BackupFile represents backup file
type BackupFile struct {
	Name string
	Data AttachmentData
}

// FactoryDefaultType represents factory default type
type FactoryDefaultType string

const (
	FactoryDefaultHard FactoryDefaultType = "Hard"
	FactoryDefaultSoft FactoryDefaultType = "Soft"
)

// RelayOutput represents relay output
type RelayOutput struct {
	Token      string
	Properties RelayOutputSettings
}

// RelayOutputSettings represents relay output settings
type RelayOutputSettings struct {
	Mode      RelayMode
	DelayTime time.Duration
	IdleState RelayIdleState
}

// RelayMode represents relay mode
type RelayMode string

const (
	RelayModeMonostable RelayMode = "Monostable"
	RelayModeBistable   RelayMode = "Bistable"
)

// RelayIdleState represents relay idle state
type RelayIdleState string

const (
	RelayIdleStateClosed RelayIdleState = "closed"
	RelayIdleStateOpen   RelayIdleState = "open"
)

// RelayLogicalState represents relay logical state
type RelayLogicalState string

const (
	RelayLogicalStateActive   RelayLogicalState = "active"
	RelayLogicalStateInactive RelayLogicalState = "inactive"
)

// AuxiliaryData represents auxiliary command data
type AuxiliaryData string

// SupportInformation represents support information
type SupportInformation struct {
	Binary *AttachmentData
	String string
}

// SystemLogUriList represents system log URIs
type SystemLogUriList struct {
	SystemLog []SystemLogUri
}

// SystemLogUri represents system log URI
type SystemLogUri struct {
	Type SystemLogType
	Uri  string
}

// NetworkZeroConfiguration represents zero-configuration
type NetworkZeroConfiguration struct {
	InterfaceToken string
	Enabled        bool
	Addresses      []string
}

// DynamicDNSInformation represents dynamic DNS info
type DynamicDNSInformation struct {
	Type DynamicDNSType
	Name string
	TTL  time.Duration
}

// DynamicDNSType represents dynamic DNS type
type DynamicDNSType string

const (
	DynamicDNSNoUpdate      DynamicDNSType = "NoUpdate"
	DynamicDNSClientUpdates DynamicDNSType = "ClientUpdates"
	DynamicDNSServerUpdates DynamicDNSType = "ServerUpdates"
)

// IPAddressFilter represents IP address filter
type IPAddressFilter struct {
	Type        IPAddressFilterType
	IPv4Address []PrefixedIPv4Address
	IPv6Address []PrefixedIPv6Address
}

// IPAddressFilterType represents filter type
type IPAddressFilterType string

const (
	IPAddressFilterAllow IPAddressFilterType = "Allow"
	IPAddressFilterDeny  IPAddressFilterType = "Deny"
)

// RemoteUser represents remote user configuration
type RemoteUser struct {
	Username           string
	Password           string
	UseDerivedPassword bool
}

// Certificate represents a certificate
type Certificate struct {
	CertificateID string
	Certificate   BinaryData
}

// BinaryData represents binary data
type BinaryData struct {
	ContentType string
	Data        []byte
}

// CertificateStatus represents certificate status
type CertificateStatus struct {
	CertificateID string
	Status        bool
}

// CertificateInformation represents certificate information
type CertificateInformation struct {
	CertificateID      string
	IssuerDN           string
	SubjectDN          string
	KeyUsage           *CertificateUsage
	ExtendedKeyUsage   *CertificateUsage
	KeyLength          int
	Version            string
	SerialNum          string
	SignatureAlgorithm string
	Validity           *DateTimeRange
}

// CertificateUsage represents certificate usage
type CertificateUsage struct {
	Critical bool
	Value    string
}

// DateTimeRange represents date/time range
type DateTimeRange struct {
	From  time.Time
	Until time.Time
}

// Dot11Capabilities represents 802.11 capabilities
type Dot11Capabilities struct {
	TKIP                  bool
	ScanAvailableNetworks bool
	MultipleConfiguration bool
	AdHocStationMode      bool
	WEP                   bool
}

// Dot11Status represents 802.11 status
type Dot11Status struct {
	SSID              string
	BSSID             string
	PairCipher        Dot11Cipher
	GroupCipher       Dot11Cipher
	SignalStrength    Dot11SignalStrength
	ActiveConfigAlias string
}

// Dot11Cipher represents 802.11 cipher
type Dot11Cipher string

const (
	Dot11CipherCCMP     Dot11Cipher = "CCMP"
	Dot11CipherTKIP     Dot11Cipher = "TKIP"
	Dot11CipherAny      Dot11Cipher = "Any"
	Dot11CipherExtended Dot11Cipher = "Extended"
)

// Dot11SignalStrength represents signal strength
type Dot11SignalStrength string

const (
	Dot11SignalNone     Dot11SignalStrength = "None"
	Dot11SignalVeryBad  Dot11SignalStrength = "Very Bad"
	Dot11SignalBad      Dot11SignalStrength = "Bad"
	Dot11SignalGood     Dot11SignalStrength = "Good"
	Dot11SignalVeryGood Dot11SignalStrength = "Very Good"
	Dot11SignalExtended Dot11SignalStrength = "Extended"
)

// Dot1XConfiguration represents 802.1X configuration
type Dot1XConfiguration struct {
	Dot1XConfigurationToken string
	Identity                string
	AnonymousID             string
	EAPMethod               int
	CACertificateID         []string
	EAPMethodConfiguration  *EAPMethodConfiguration
}

// EAPMethodConfiguration represents EAP method configuration
type EAPMethodConfiguration struct {
	TLSConfiguration *TLSConfiguration
	Password         string
}

// TLSConfiguration represents TLS configuration
type TLSConfiguration struct {
	CertificateID string
}

// Dot11AvailableNetworks represents available 802.11 networks
type Dot11AvailableNetworks struct {
	SSID                  string
	BSSID                 string
	AuthAndMangementSuite []Dot11AuthAndMangementSuite
	PairCipher            []Dot11Cipher
	GroupCipher           []Dot11Cipher
	SignalStrength        Dot11SignalStrength
}

// Dot11AuthAndMangementSuite represents auth suite
type Dot11AuthAndMangementSuite string

const (
	Dot11AuthNone     Dot11AuthAndMangementSuite = "None"
	Dot11AuthDot1X    Dot11AuthAndMangementSuite = "Dot1X"
	Dot11AuthPSK      Dot11AuthAndMangementSuite = "PSK"
	Dot11AuthExtended Dot11AuthAndMangementSuite = "Extended"
)

// StorageConfiguration represents storage configuration
type StorageConfiguration struct {
	Token string
	Data  StorageConfigurationData
}

// StorageConfigurationData represents storage configuration data
type StorageConfigurationData struct {
	Type                       string
	LocalPath                  string
	StorageUri                 string
	User                       *UserCredential
	CertPathValidationPolicyID string
}

// UserCredential represents user credentials
type UserCredential struct {
	UserName string
	Password string
	Token    string
}

// LocationEntity represents geo location
type LocationEntity struct {
	Entity    string  `xml:"Entity"`
	Token     string  `xml:"Token"`
	Fixed     bool    `xml:"Fixed"`
	Lon       float64 `xml:"Lon,attr"`
	Lat       float64 `xml:"Lat,attr"`
	Elevation float64 `xml:"Elevation,attr"`
}

// GeoLocation represents geographic location coordinates
type GeoLocation struct {
	Lon       float64 `xml:"lon,attr,omitempty"`       // Longitude in degrees
	Lat       float64 `xml:"lat,attr,omitempty"`       // Latitude in degrees
	Elevation float64 `xml:"elevation,attr,omitempty"` // Elevation in meters
}

// AccessPolicy represents device access policy configuration
type AccessPolicy struct {
	PolicyFile *BinaryData
}

// PasswordComplexityConfiguration represents password complexity config
type PasswordComplexityConfiguration struct {
	MinLen                    int
	Uppercase                 int
	Number                    int
	SpecialChars              int
	BlockUsernameOccurrence   bool
	PolicyConfigurationLocked bool
}

// PasswordHistoryConfiguration represents password history config
type PasswordHistoryConfiguration struct {
	Enabled bool
	Length  int
}

// AuthFailureWarningConfiguration represents auth failure warning config
type AuthFailureWarningConfiguration struct {
	Enabled         bool
	MonitorPeriod   int
	MaxAuthFailures int
}

// IntRange represents integer range
type IntRange struct {
	Min int
	Max int
}