geneos

type APIPlugin struct {
	XMLName     xml.Name             `xml:"api" json:"-" yaml:"-"`
	Parameters  []Parameter          `xml:"parameters>parameter"`
	SummaryView *SingleLineStringVar `xml:"showSummaryView>always>viewName,omitempty"`
}

type APIStreamsPlugin struct {
	XMLName    xml.Name `xml:"api-streams" json:"-" yaml:"-"`
	Streams    *Streams `xml:"streams"`
	BufferSize *Value   `xml:"bufferSize,omitempty"`
	CreateView *Value   `xml:"createView,omitempty"`
}

type ActiveTimeByName struct {
	XMLName    xml.Name `xml:"activeTime"`
	ActiveTime string   `xml:"ref,attr"`
}

type ActiveTimeRef struct {
	XMLName    xml.Name          `xml:"activeTime"`
	ActiveTime *ActiveTimeByName `xml:"activeTime,omitempty"`
	Var        *Var              `xml:"var,omitempty"`
}

type AddTypes struct {
	XMLName xml.Name         `xml:"addTypes" json:"-" yaml:"-"`
	Types   []TypeRefWithEnv `xml:"type,omitempty" json:",omitempty" yaml:",omitempty" mapstructure:"type"`
}

type Attribute struct {
	XMLName xml.Name `xml:"attribute" json:"-" yaml:"-"`
	Name    string   `xml:"name,attr"`
	Value   string   `xml:",innerxml" mapstructure:"#text"`
}

type CPUPlugin struct {
	XMLName xml.Name `xml:"cpu" json:"-" yaml:"-"`
}

type CollectionAgent struct {
	Start        bool   `xml:"start,omitempty"`
	JVMArgs      string `xml:"jvmArgs,omitempty"`
	HealthPort   int    `xml:"healthPort,omitempty"`
	ReporterPort int    `xml:"reporterPort,omitempty"`
	Detached     bool   `xml:"detached"`
}

type ControlMDataview struct {
	Name       string              `xml:"name"`
	Parameters []ControlMParameter `xml:"parameters,omitempty"`
	Columns    []string            `xml:"columns>column,omitempty"`
}

type ControlMParameter struct {
	Parameter string `xml:"parameter"`
	Criteria  string `xml:"criteria"`
}

type ControlMPlugin struct {
	XMLName   xml.Name           `xml:"control-m" json:"-" yaml:"-"`
	Host      *Host              `xml:"host"`
	Port      *Value             `xml:"port"`
	Username  *Value             `xml:"username"`
	Password  *Value             `xml:"password"`
	Timeout   *Value             `xml:"timeout,omitempty"`
	Dataviews []ControlMDataview `xml:"dataviews>dataview,omitempty"`
}

type DBConnection struct {
	MySQL                     *MySQL               `xml:"database>mysql,omitempty"`
	SQLServer                 *SQLServer           `xml:"database>sqlServer,omitempty"`
	Sybase                    *Sybase              `xml:"database>sybase,omitempty"`
	Oracle                    *Oracle              `xml:"database>oracle,omitempty"`
	Username                  *SingleLineStringVar `xml:"var-userName"`
	Password                  *SingleLineStringVar `xml:"password"`
	CloseConnectionAfterQuery *Value               `xml:"closeConnectionAfterQuery,omitempty"`
}

type Data struct {
	XMLName xml.Name `xml:"data" json:"-" yaml:"-"`
	Data    string   `xml:",chardata"`
}

type Dataview struct {
	Name      string            `xml:"name,attr"`
	Additions DataviewAdditions `xml:"additions,omitempty" json:",omitempty" yaml:",omitempty"`
}

type DataviewAddition struct {
	XMLName xml.Name             `xml:"data" json:"-" yaml:"-"`
	Name    *SingleLineStringVar `xml:"headline,omitempty"`
}

type DataviewAdditionColumns struct {
	Var       *Var                  `xml:"var,omitempty"`
	Headlines []SingleLineStringVar `xml:"data>column,omitempty"`
}

type DataviewAdditionHeadlines struct {
	Var       *Var                  `xml:"var,omitempty"`
	Headlines []SingleLineStringVar `xml:"data>headline,omitempty"`
}

type DataviewAdditionRows struct {
	Var       *Var                  `xml:"var,omitempty"`
	Headlines []SingleLineStringVar `xml:"data>rows,omitempty"`
}

type DataviewAdditions struct {
	XMLName   xml.Name                  `xml:"additions" json:"-" yaml:"-"`
	Headlines DataviewAdditionHeadlines `xml:"var-headlines,omitempty"`
	Columns   DataviewAdditionColumns   `xml:"var-columns,omitempty"`
	Rows      DataviewAdditionRows      `xml:"var-rows,omitempty"`
}

type DataviewSchema struct {
	Dataview string `xml:"dataview,omitempty"`
	Schema   Schema `xml:"schema>data"`
}

type DeviceIOPlugin struct {
	XMLName xml.Name `xml:"deviceio" json:"-" yaml:"-"`
}

type DiskPlugin struct {
	XMLName              xml.Name           `xml:"disk" json:"-" yaml:"-"`
	Partitions           []Partition        `xml:"partitions>partition,omitempty"`
	ExcludePartitions    []ExcludePartition `xml:"excludePartitions>excludePartition,omitempty"`
	AutoDetect           *Value             `xml:"autoDetect,omitempty"`
	MaximumPartitions    *Value             `xml:"maximumPartitions,omitempty"`
	CheckNFSPartitions   *Value             `xml:"checkNFSPartitions,omitempty"`
	MatchExactPartitions *Value             `xml:"matchExactPartitions,omitempty"`
}

type DynamicEntities struct {
	MappingType []string `xml:"mappingType,omitempty"`
}

type EmptyStruct struct{}

type Environment struct {
	XMLName      xml.Name      `xml:"environment" json:"-" yaml:"-"`
	Name         string        `xml:"name,attr"`
	Environments []Environment `xml:"environment,omitempty" json:",omitempty" yaml:",omitempty"`
	Vars         []Vars        `xml:"var,omitempty" json:",omitempty" yaml:",omitempty" mapstructure:"var"`
}

type EnvironmentGroup struct {
	XMLName      xml.Name      `xml:"environmentGroup" json:"-" yaml:"-"`
	Name         string        `xml:"name,attr"`
	Environments []Environment `xml:"environment,omitempty" json:",omitempty" yaml:",omitempty"`
}

type EnvironmentRef struct {
	XMLName xml.Name `xml:"environment" json:"-" yaml:"-"`
	Name    string   `xml:"ref,attr" json:",omitempty" yaml:",omitempty"`
}

type EnvironmentVariable struct {
	XMLName xml.Name             `xml:"variable"  json:"-" yaml:"-"`
	Name    string               `xml:"name"`
	Value   *SingleLineStringVar `xml:"value"`
}

type Environments struct {
	XMLName      xml.Name           `xml:"environments" json:"-" yaml:"-"`
	Groups       []EnvironmentGroup `xml:"environmentGroup,omitempty" json:",omitempty" yaml:",omitempty"`
	Environments []Environment      `xml:"environment,omitempty" json:",omitempty" yaml:",omitempty"`
}

type ExcludePartition struct {
	Path       string `xml:"path"`
	FileSystem string `xml:"fileSystem"`
}

type FIXAnalyser2Plugin struct {
	XMLName xml.Name `xml:"fix-analyser2" json:"-" yaml:"-"`
}

type FKMDisplay struct {
	TriggerMode string `xml:"triggerMode,omitempty" json:",omitempty" yaml:",omitempty"`
}

type FKMFile struct {
	XMLName             xml.Name       `xml:"file" json:"-" yaml:"-"`
	Source              *FKMFileSource `xml:"source"`
	Tables              []FKMTable     `xml:"tables>table,omitempty" json:",omitempty" yaml:",omitempty" mapstructure:"tables"`
	ClearTime           *Value         `xml:"clearTime,omitempty" json:",omitempty" yaml:",omitempty"`
	DefaultKeyClearTime *Value         `xml:"defaultKeyClearTime,omitempty" json:",omitempty" yaml:",omitempty"`
	Rewind              *Value         `xml:"rewind,omitempty" json:",omitempty" yaml:",omitempty"`
	Alias               *Value         `xml:"alias,omitempty" json:",omitempty" yaml:",omitempty"`
}

type FKMFileSource struct {
	Filename          *SingleLineStringVar `xml:"filename,omitempty" json:",omitempty" yaml:",omitempty" mapstructure:"filename"`
	Stream            *SingleLineStringVar `xml:"stream,omitempty" json:",omitempty" yaml:",omitempty" mapstructure:"stream"`
	NTEventLog        string               `xml:"ntEventLog,omitempty" json:",omitempty" yaml:",omitempty" mapstructure:"ntEventLog"`
	ProcessDescriptor *Reference           `xml:"processDescriptor,omitempty" json:",omitempty" yaml:",omitempty" mapstructure:"processDescriptor"`
}

type FKMFiles struct {
	XMLName xml.Name  `xml:"files" json:"-" yaml:"-"`
	Files   []FKMFile `xml:"file,omitempty" json:",omitempty" yaml:",omitempty" mapstructure:"file"`
}

type FKMIgnoreKey struct {
	XMLName xml.Name `xml:"ignoreKey" json:"-" yaml:"-"`
	Match   FKMMatch `xml:"match"`
}

type FKMKey struct {
	XMLName  xml.Name  `xml:"key" json:"-" yaml:"-"`
	SetKey   FKMSetKey `xml:"setKey"`
	ClearKey *FKMMatch `xml:"clearKey,omitempty"`
	Message  *Value    `xml:"message,omitempty"`
	Severity string    `xml:"severity,omitempty"`
}

type FKMKeyData struct {
	XMLName xml.Name `xml:"data" json:"-" yaml:"-"`
	Keys    FKMKeys
}

type FKMKeyTable struct {
	XMLName xml.Name `xml:"fkmTable" json:"-" yaml:"-"`
	Name    string   `xml:"ref,attr"`
}

type FKMKeys struct {
	XMLName xml.Name      `xml:"keys" json:"-" yaml:"-"`
	Keys    []interface{} // should be FKMIgnoreKey or FKMKey
}

type FKMMatch struct {
	SearchString *SingleLineStringVar `xml:"searchString"`
	Rules        FKMMatchRules        `xml:"rules,omitempty"`
}

type FKMMatchRules string

type FKMPlugin struct {
	XMLName xml.Name    `xml:"fkm" json:"-" yaml:"-"`
	Display *FKMDisplay `xml:"display,omitempty" json:",omitempty" yaml:",omitempty"`
	Files   FKMFiles    `xml:"files,omitempty" json:",omitempty" yaml:",omitempty" mapstructure:"files"`
}

type FKMSetKey struct {
	Match        *FKMMatch `xml:"match,omitempty"`
	NotUpdatedIn *Value    `xml:"notUpdatedIn>timePeriodInSeconds,omitempty"`
	Updated      string    `xml:"updated,omitempty"`
}

type FKMStaticKeyTable struct {
	XMLName xml.Name `xml:"fkmTable" json:"-" yaml:"-"`
	Name    string   `xml:"name,attr"`
	Keys    FKMKeys
}

type FKMTable struct {
	XMLName  xml.Name `xml:"table" json:"-" yaml:"-"`
	Severity string   `xml:"severity"`
	KeyTable *Value   `xml:"keyTable"`
}

type FTMAdditionalPaths struct {
	Paths []*SingleLineStringVar `xml:"additionalPath"`
}

type FTMFile struct {
	XMLName         xml.Name             `xml:"file" json:"-" yaml:"-"`
	Path            *SingleLineStringVar `xml:"path"`
	AdditionalPaths *FTMAdditionalPaths  `xml:"additionalPaths,omitempty"`
	ExpectedArrival *Value               `xml:"expectedArrival,omitempty"`
	ExpectedPeriod  *struct {
		Period string `xml:",innerxml"`
	} `xml:"expectedPeriod,omitempty"`
	TZOffset         *Value               `xml:"tzOffset,omitempty"`
	MonitoringPeriod interface{}          `xml:"monitoringPeriod"`
	Alias            *SingleLineStringVar `xml:"alias"`
}

type FTMHolidaysVars struct {
	XMLName xml.Name               `xml:"holidaysVar" json:"-" yaml:"-"`
	Holiday []*SingleLineStringVar `xml:"holiday,omitempty"`
	Day     *FTMWeekdays           `xml:"day,omitempty"`
}

type FTMPlugin struct {
	XMLName                    xml.Name         `xml:"ftm" json:"-" yaml:"-"`
	Files                      []FTMFile        `xml:"files>file"`
	Holidays                   *FTMHolidaysVars `xml:"holidaysVar,omitempty"`
	MonitoredDays              *FTMWeekdays     `xml:"monitoredDays,omitempty"`
	ConsistentDateStamps       *Value           `xml:"consistentDateStamps,omitempty"`
	DisplayTimeInISO8601Format *Value           `xml:"displayTimeInIso8601Format,omitempty"`
	ShowActualFilename         *Value           `xml:"showActualFilename,omitempty"`
	DelayUnit                  string           `xml:"delayUnit"`
	SizeUnit                   string           `xml:"sizeUnit"`
}

type FTMWeekdays struct {
	Monday    bool `xml:"monday"`
	Tuesday   bool `xml:"tuesday"`
	Wednesday bool `xml:"wednesday"`
	Thursday  bool `xml:"thursday"`
	Friday    bool `xml:"friday"`
	Saturday  bool `xml:"saturday"`
	Sunday    bool `xml:"sunday"`
}

type FilterAttribute struct {
	Name   string   `xml:"name"`
	Values []string `xml:"values>value"`
}

type FilterByAttribute struct {
	XMLName xml.Name         `xml:"attribute" json:"-" yaml:"-"`
	Include *FilterAttribute `xml:"include,omitempty"`
	Exclude *FilterAttribute `xml:"exclude,omitempty"`
}

type FloatingNetprobe struct {
	Enabled                  bool       `xml:"enabled"`
	RetryInterval            int        `xml:"retryInterval,omitempty"`
	RequireReverseConnection bool       `xml:"requireReverseConnection,omitempty"`
	ProbeName                string     `xml:"probeName"`
	Gateways                 []Gateways `xml:"gateways"`
}

type FloatingProbe struct {
	XMLName              xml.Name `xml:"floatingProbe" json:"-" yaml:"-"`
	Name                 string   `xml:"name.attr" json:"name" yaml:"name"`
	Disabled             bool     `xml:"disabled,attr,omitempty" json:",omitempty" yaml:",omitempty"`
	ProbeInfoWithoutPort `yaml:",inline" mapstructure:",squash"`
}

type GWSQLColumn struct {
	Name  *SingleLineStringVar `xml:"name"`
	XPath string               `xml:"xpath,omitempty"`
	Type  string               `xml:"type,omitempty"`
}

type GWSQLView struct {
	XMLName  xml.Name             `xml:"view" json:"-" yaml:"-"`
	ViewName *SingleLineStringVar `xml:"name"`
	SQL      *SingleLineStringVar `xml:"sql"`
}

type Gateway struct {
	XMLName              xml.Name              `xml:"gateway"`
	Compatibility        int                   `xml:"compatibility,attr"`
	XMLNs                string                `xml:"xmlns:xsi,attr"`                     // http://www.w3.org/2001/XMLSchema-instance
	XSI                  string                `xml:"xsi:noNamespaceSchemaLocation,attr"` // http://schema.itrsgroup.com/GA5.12.0-220125/gateway.xsd
	Probes               *Probes               `xml:"probes"`
	ManagedEntities      *ManagedEntities      `xml:"managedEntities,omitempty"`
	Types                *Types                `xml:"types,omitempty"`
	Samplers             *Samplers             `xml:"samplers,omitempty"`
	Rules                *Rules                `xml:"rules,omitempty"`
	Environments         *Environments         `xml:"environments,omitempty"`
	ProcessDescriptors   *ProcessDescriptors   `xml:"staticVars>processDescriptors,omitempty"`
	OperatingEnvironment *OperatingEnvironment `xml:"operatingEnvironment,omitempty"`
}

type GatewayBreachPredictorPlugin struct {
	XMLName xml.Name `xml:"Gateway-breachPredictor" json:"-" yaml:"-"`
}

type GatewayClientConnectionDataPlugin struct {
	XMLName xml.Name `xml:"Gateway-clientConnectionData" json:"-" yaml:"-"`
}

type GatewayDataPlugin struct {
	XMLName xml.Name `xml:"Gateway-gatewayData" json:"-" yaml:"-"`
}

type GatewayDatabaseLoggingPlugin struct {
	XMLName xml.Name `xml:"Gateway-databaseLogging" json:"-" yaml:"-"`
}

type GatewayExportedDataPlugin struct {
	XMLName xml.Name `xml:"Gateway-exportedData" json:"-" yaml:"-"`
}

type GatewayHubDataPlugin struct {
	XMLName xml.Name `xml:"Gateway-gatewayHubData" json:"-" yaml:"-"`
}

type GatewayImportedDataPlugin struct {
	XMLName xml.Name `xml:"Gateway-importedData" json:"-" yaml:"-"`
}

type GatewayIncludesDataPlugin struct {
	XMLName xml.Name `xml:"Gateway-includesData" json:"-" yaml:"-"`
}

type GatewayLicenceUsagePlugin struct {
	XMLName xml.Name `xml:"Gateway-licenceUsage" json:"-" yaml:"-"`
}

type GatewayLoadPlugin struct {
	XMLName xml.Name `xml:"Gateway-gatewayLoad" json:"-" yaml:"-"`
}

type GatewayManagedEntityDataPlugin struct {
	XMLName xml.Name `xml:"Gateway-managedEntitiesData" json:"-" yaml:"-"`
}

type GatewayObcervConnectionPlugin struct {
	XMLName xml.Name `xml:"Gateway-obcervConnection" json:"-" yaml:"-"`
}

type GatewayProbeDataPlugin struct {
	XMLName xml.Name `xml:"Gateway-probeData" json:"-" yaml:"-"`
}

type GatewaySQLPlugin struct {
	XMLName xml.Name             `xml:"Gateway-sql" json:"-" yaml:"-"`
	Setup   *SingleLineStringVar `xml:"setupSql>sql"`
	Tables  *GatewaySQLTables    `xml:"tables"`
	Sample  *SingleLineStringVar `xml:"sampleSql>sql"`
	Views   []GWSQLView          `xml:"views>view"`
}

type GatewaySQLTableDataview struct {
	XMLName xml.Name             `xml:"dataview" json:"-" yaml:"-"`
	Name    *SingleLineStringVar `xml:"tableName"`
	XPath   string               `xml:"xpath"`
	Columns *[]GWSQLColumn       `xml:"columns>column,omitempty"`
}

type GatewaySQLTableHeadline struct {
	XMLName xml.Name             `xml:"headlines" json:"-" yaml:"-"`
	Name    *SingleLineStringVar `xml:"tableName"`
	XPath   string               `xml:"xpath"`
}

type GatewaySQLTableXPath struct {
	XMLName xml.Name             `xml:"xpath" json:"-" yaml:"-"`
	Name    *SingleLineStringVar `xml:"tableName"`
	XPaths  []string             `xml:"xpaths>xpath"`
	Columns []GWSQLColumn        `xml:"columns>column"`
}

type GatewaySQLTables struct {
	Tables []interface{}
}

type GatewayScheduledCommandDataPlugin struct {
	XMLName xml.Name `xml:"Gateway-scheduledCommandData" json:"-" yaml:"-"`
}

type GatewayScheduledCommandsHistoryDataPlugin struct {
	XMLName xml.Name `xml:"Gateway-scheduledCommandsHistoryData" json:"-" yaml:"-"`
}

type GatewaySeverityCountPlugin struct {
	XMLName             xml.Name            `xml:"Gateway-severityCount" json:"-" yaml:"-"`
	Viewpaths           []string            `xml:"viewPaths>viewPath,omitempty"`
	IncludeUserAssigned bool                `xml:"includeUserAssigned,omitempty"`
	IncludeSnoozed      bool                `xml:"includeSnoozed,omitempty"`
	IncludeInactive     bool                `xml:"includeInactive,omitempty"`
	AppendManagedEntity bool                `xml:"appendManagedEntity,omitempty"`
	FilterByAttribute   []FilterByAttribute `xml:"filterByAttribute>attribute,omitempty"`
}

type GatewaySeverityDataPlugin struct {
	XMLName xml.Name `xml:"Gateway-severityData" json:"-" yaml:"-"`
}

type GatewaySnoozeDataPlugin struct {
	XMLName xml.Name `xml:"Gateway-snoozeData" json:"-" yaml:"-"`
}

type GatewayUserAssignmentDataPlugin struct {
	XMLName xml.Name `xml:"Gateway-userAssignmentData" json:"-" yaml:"-"`
}

type Gateways struct {
	XMLName  xml.Name `xml:"gateway"`
	Hostname string   `xml:"hostname"`
	Port     int      `xml:"port,omitempty"`
	Secure   bool     `xml:"secure,omitempty"`
}

type HardwarePlugin struct {
	XMLName xml.Name `xml:"hardware" json:"-" yaml:"-"`
}

type Host struct {
	Name      string     `xml:"name,omitempty"`
	IPAddress *IPAddress `xml:"ipAddress,omitempty"`
	Var       *Reference `xml:"var,omitempty"`
}

type IPAddress struct {
	Octets []int `xml:"value"` // must be []int else unmarshal treats []uint8 as a []byte
}

type JMXConnection struct {
	Generic   *JMXGenericConnection
	WebLogic  *JMXWebLogicConnection
	WebSphere *JMXWebSphereConnection
}

type JMXGenericConnection struct {
	ServiceURL        *SingleLineStringVar
	ConnectionDetails *JMXGenericConnectionDetails
	JMXId             *SingleLineStringVar
	Username          *SingleLineStringVar
	Password          *Value
	Timeout           *Value
}

type JMXGenericConnectionDetails struct {
	Host    *SingleLineStringVar
	Port    *Value
	URLPath *SingleLineStringVar
}

type JMXServerPlugin struct {
	XMLName    xml.Name      `xml:"jmx-server" json:"-" yaml:"-"`
	Connection JMXConnection `xml:"connection"`
}

type JMXWebLogicConnection struct {
	URL         *SingleLineStringVar
	Principal   *SingleLineStringVar
	Credentials *Value
	Certificate *SingleLineStringVar
	Key         *SingleLineStringVar
	Password    *Value
}

type JMXWebSphereConnection struct {
	Host                        *SingleLineStringVar
	Port                        *Value
	Username                    *SingleLineStringVar
	Password                    *Value
	Type                        *SingleLineStringVar
	SSLClientKeyStore           *SingleLineStringVar
	SSLClientKeyStorePassword   *Value
	SSLClientTrustStore         *SingleLineStringVar
	SSLClientTrustStorePassword *Value
}

type KeyedObject interface {
	GetKey() string
}

type MQChannel struct {
	Matches    *SingleLineStringVar `xml:"matches,omitempty"`
	StartsWith *SingleLineStringVar `xml:"startsWith,omitempty"`
}

type MQChannelPlugin struct {
	XMLName      xml.Name      `xml:"mq-channel" json:"-" yaml:"-"`
	Connection   *MQConnection `xml:"connection,omitempty"`
	QueueManager *Value        `xml:"queueManager"`
	Channels     []MQChannel   `xml:"channels>channel,omitempty"`
	Columns      []string      `xml:"columns>column,omitempty"`
}

type MQConnection struct {
	MQServer       *SingleLineStringVar `xml:"mqServer,omitempty"`
	MQChannelTable *SingleLineStringVar `xml:"mqChannelTable,omitempty"`
}

type MQQInfoPlugin struct {
	XMLName         xml.Name             `xml:"mq-qinfo" json:"-" yaml:"-"`
	Queuemanager    *Value               `xml:"queueManager"`
	MQServer        *SingleLineStringVar `xml:"mqServer,omitempty"`
	QueueName       *SingleLineStringVar `xml:"queueName"`
	HideUnavailable *SingleLineStringVar `xml:"hideUnavailable,omitempty"`
}

type MQQueue struct {
	Matches    *SingleLineStringVar `xml:"matches,omitempty"`
	StartsWith *SingleLineStringVar `xml:"startsWith,omitempty"`
}

type MQQueuePlugin struct {
	XMLName      xml.Name      `xml:"mq-queue" json:"-" yaml:"-"`
	Connection   *MQConnection `xml:"connection,omitempty"`
	QueueManager *Value        `xml:"queueManager"`
	Queues       []MQQueue     `xml:"queues>queue,omitempty"`
	Columns      []string      `xml:"columns>column,omitempty"`
}

type Macro struct {
	InsecureGatewayPort *EmptyStruct `xml:"insecureGatewayPort,omitempty" json:",omitempty" yaml:",omitempty"`
	GatewayName         *EmptyStruct `xml:"gatewayName,omitempty" json:",omitempty" yaml:",omitempty"`
	NetprobeName        *EmptyStruct `xml:"netprobeName,omitempty" json:",omitempty" yaml:",omitempty"`
	NetprobeHost        *EmptyStruct `xml:"netprobeHost,omitempty" json:",omitempty" yaml:",omitempty"`
	NetprobePort        *EmptyStruct `xml:"netprobePort,omitempty" json:",omitempty" yaml:",omitempty"`
	ManagedEntitiesName *EmptyStruct `xml:"managedEntityName,omitempty" json:",omitempty" yaml:",omitempty"`
	SamplerName         *EmptyStruct `xml:"samplerName,omitempty" json:",omitempty" yaml:",omitempty"`
	SecureGatewayPort   *EmptyStruct `xml:"secureGatewayPort,omitempty" json:",omitempty" yaml:",omitempty"`
}

type ManagedEntities struct {
	XMLName             xml.Name             `xml:"managedEntities" json:"-" yaml:"-"`
	Entities            []ManagedEntity      `xml:"managedEntity,omitempty" json:",omitempty" yaml:",omitempty" mapstructure:"managedentity"`
	ManagedEntityGroups []ManagedEntityGroup `xml:"managedEntityGroup,omitempty" json:",omitempty" yaml:",omitempty" mapstructure:"managedentitygroup"`
}

type ManagedEntity struct {
	XMLName           xml.Name        `xml:"managedEntity" json:"-" yaml:"-"`
	Name              string          `xml:"name,attr"`
	Disabled          bool            `xml:"disabled,attr,omitempty" json:",omitempty" yaml:",omitempty"`
	Probe             *Reference      `xml:"probe" json:",omitempty" yaml:",omitempty"`
	FloatingProbe     *Reference      `xml:"floatingProbe" json:",omitempty" yaml:",omitempty"`
	VirtualProbe      *Reference      `xml:"virtualProbe" json:",omitempty" yaml:",omitempty"`
	Environment       *EnvironmentRef `xml:"environment,omitempty" json:",omitempty" yaml:",omitempty"`
	ManagedEntityInfo `yaml:",inline" mapstructure:",squash"`
	Samplers          []SamplerRef `xml:"sampler,omitempty" json:",omitempty" yaml:",omitempty" mapstructure:"sampler"`
}

type ManagedEntityGroup struct {
	XMLName             xml.Name `xml:"managedEntityGroup" json:"-" yaml:"-"`
	Name                string   `xml:"name,attr"`
	Disabled            bool     `xml:"disabled,attr,omitempty" json:",omitempty" yaml:",omitempty"`
	ManagedEntityInfo   `yaml:",inline" mapstructure:",squash"`
	Entities            []ManagedEntity      `xml:"managedEntity,omitempty" json:",omitempty" yaml:",omitempty" mapstructure:"managedentity"`
	ManagedEntityGroups []ManagedEntityGroup `xml:"managedEntityGroup,omitempty" json:",omitempty" yaml:",omitempty" mapstructure:"managedentitygroup"`
}

type ManagedEntityInfo struct {
	Attributes       []Attribute     `xml:"attribute,omitempty" json:",omitempty" yaml:",omitempty" mapstructure:"attribute"`
	RemoveTypes      *RemoveTypes    `xml:"removeTypes,omitempty" json:",omitempty" yaml:",omitempty"`
	RemoveSamplers   *RemoveSamplers `xml:"removeSamplers,omitempty" json:",omitempty" yaml:",omitempty"`
	AddTypes         *AddTypes       `xml:"addTypes,omitempty" json:",omitempty" yaml:",omitempty"`
	Vars             []Vars          `xml:"var,omitempty" json:",omitempty" yaml:",omitempty" mapstructure:"var"`
	ResolvedSamplers map[string]bool `xml:"-" json:",omitempty" yaml:",omitempty"` // map of "type:sampler" that exist at this point
}

type MonitoringPeriodAlias struct {
	Alias string `xml:"periodAlias"`
}

type MonitoringPeriodStart struct {
	PeriodStart *Value `xml:"periodStartTime,omitempty"`
}

type MySQL struct {
	ServerName *SingleLineStringVar `xml:"var-serverName,omitempty"`
	DBName     *SingleLineStringVar `xml:"var-databaseName,omitempty"`
	Port       *SingleLineStringVar `xml:"var-port,omitempty"`
}

type NameContents struct {
	ShowLocalAddress  *Value `xml:"showLocalAddress,omitempty" json:"showLocalAddress,omitempty" yaml:"showLocalAddress,omitempty"`
	ShowLocalPort     *Value `xml:"showLocalPort,omitempty" json:"showLocalPort,omitempty" yaml:"showLocalPort,omitempty"`
	ShowRemoteAddress *Value `xml:"showRemoteAddress,omitempty" json:"showRemoteAddress,omitempty" yaml:"showRemoteAddress,omitempty"`
	ShowRemotePort    *Value `xml:"showRemotePort,omitempty" json:"showRemotePort,omitempty" yaml:"showRemotePort,omitempty"`
}

type NameValue struct {
	Name  string `xml:"name"`
	Value string `xml:"value"`
}

type NameValueList struct {
	NameValues []NameValue `xml:"item,omitempty" json:",omitempty" yaml:",omitempty"`
}

type Netprobe struct {
	XMLName          xml.Name          `xml:"netprobe"`
	Compatibility    int               `xml:"compatibility,attr"`                 // 1
	XMLNs            string            `xml:"xmlns:xsi,attr"`                     // http://www.w3.org/2001/XMLSchema-instance
	XSI              string            `xml:"xsi:noNamespaceSchemaLocation,attr"` // http://schema.itrsgroup.com/GA5.12.0-220125/netprobe.xsd
	FloatingNetprobe *FloatingNetprobe `xml:"floatingProbe,omitempty"`
	PluginWhiteList  []string          `xml:"pluginWhiteList,omitempty"`
	CommandWhiteList []string          `xml:"commandWhiteList,omitempty"`
	SelfAnnounce     *SelfAnnounce     `xml:"selfAnnounce,omitempty"`
}

type NetworkPlugin struct {
	XMLName xml.Name `xml:"network" json:"-" yaml:"-"`
}

type OperatingEnvironment struct {
	XMLName      xml.Name `xml:"operatingEnvironment"`
	GatewayID    int      `xml:"gatewayId"`
	GatewayName  string   `xml:"gatewayName"`
	SecurePort   int      `xml:"listenPorts>secure>listenPort,omitempty"`
	InsecurePort int      `xml:"listenPorts>insecure>listenPort,omitempty"`
}

type Oracle struct {
	DBName          *SingleLineStringVar `xml:"var-databaseName,omitempty"`
	DBNameAlt       *SingleLineStringVar `xml:"databaseName,omitempty"`
	ApplicationName *SingleLineStringVar `xml:"var-applicationName,omitempty"`
}

type Parameter struct {
	Name  string               `xml:"name"`
	Value *SingleLineStringVar `xml:"value"`
}

type Partition struct {
	Path  *SingleLineStringVar `xml:"path"`
	Alias *SingleLineStringVar `xml:"alias"`
}

type PerfmonPlugin struct {
	XMLName xml.Name `xml:"perfmon" json:"-" yaml:"-"`
}

type PlainType struct {
	Type string `xml:"type"`
}

type Plugin struct {
	// api.go
	API        *APIPlugin        `xml:"api,omitempty" json:"api,omitempty" yaml:"api,omitempty"`
	APIStreams *APIStreamsPlugin `xml:"api-streams,omitempty" json:"api-streams,omitempty" yaml:"api-streams,omitempty"`

	// control-m.go
	ControlM *ControlMPlugin `xml:"control-m,omitempty" json:"control-m,omitempty" yaml:"control-m,omitempty"`

	// fix-analyser.go
	FIXAnalyser2 *FIXAnalyser2Plugin `xml:"fix-analyser2,omitempty" json:"fix-analyser2,omitempty" yaml:"fix-analyser2,omitempty"`

	// fkm.go
	FKM *FKMPlugin `xml:"fkm,omitempty" json:"fkm,omitempty" yaml:"fkm,omitempty"`

	// ftm.go
	FTM *FTMPlugin `xml:"ftm,omitempty" json:"ftm,omitempty" yaml:"ftm,omitempty"`

	// gateway-plugins.go
	GatewayBreachPredictor              *GatewayBreachPredictorPlugin              `xml:"Gateway-breachPredictor,omitempty" json:"Gateway-breachpredictor,omitempty" yaml:"Gateway-breachpredictor,omitempty"`
	GatewayClientConnectionData         *GatewayClientConnectionDataPlugin         `` /* 136-byte string literal not displayed */
	GatewayDatabaseLogging              *GatewayDatabaseLoggingPlugin              `xml:"Gateway-databaseLogging,omitempty" json:"Gateway-databaseLogging,omitempty" yaml:"Gateway-databaseLogging,omitempty"`
	GatewayExportedData                 *GatewayExportedDataPlugin                 `xml:"Gateway-exportedData,omitempty" json:"Gateway-exportedData,omitempty" yaml:"Gateway-exportedData,omitempty"`
	GatewayData                         *GatewayDataPlugin                         `xml:"Gateway-gatewayData,omitempty" json:"Gateway-gatewayData,omitempty" yaml:"Gateway-gatewayData,omitempty"`
	GatewayHubData                      *GatewayHubDataPlugin                      `xml:"Gateway-gatewayHubData,omitempty" json:"Gateway-gatewayHubData,omitempty" yaml:"Gateway-gatewayHubData,omitempty"`
	GatewayImportedData                 *GatewayImportedDataPlugin                 `xml:"Gateway-importedData,omitempty" json:"Gateway-importedData,omitempty" yaml:"Gateway-importedData,omitempty"`
	GatewayIncludesData                 *GatewayIncludesDataPlugin                 `xml:"Gateway-includesData,omitempty" json:"Gateway-includesData,omitempty" yaml:"Gateway-includesData,omitempty"`
	GatewayLicenceUsage                 *GatewayLicenceUsagePlugin                 `xml:"Gateway-licenceUsage,omitempty" json:"Gateway-licenceUsage,omitempty" yaml:"Gateway-licenceUsage,omitempty"`
	GatewayLoad                         *GatewayLoadPlugin                         `xml:"Gateway-gatewayLoad,omitempty" json:"Gateway-gatewayLoad,omitempty" yaml:"Gateway-gatewayLoad,omitempty"`
	GatewayManagedEntityData            *GatewayManagedEntityDataPlugin            `` /* 133-byte string literal not displayed */
	GatewayObcervConnection             *GatewayObcervConnectionPlugin             `xml:"Gateway-obcervConnection,omitempty" json:"Gateway-obcervConnection,omitempty" yaml:"Gateway-obcervConnection,omitempty"`
	GatewayProbeData                    *GatewayProbeDataPlugin                    `xml:"Gateway-probeData,omitempty" json:"Gateway-probeData,omitempty" yaml:"Gateway-probeData,omitempty"`
	GatewayScheduledCommandsHistoryData *GatewayScheduledCommandsHistoryDataPlugin `` /* 160-byte string literal not displayed */
	GatewayScheduledCommandData         *GatewayScheduledCommandDataPlugin         `` /* 136-byte string literal not displayed */
	GatewaySeverityCount                *GatewaySeverityCountPlugin                `xml:"Gateway-severityCount,omitempty" json:"Gateway-severityCount,omitempty" yaml:"Gateway-severityCount,omitempty"`
	GatewaySeverityData                 *GatewaySeverityDataPlugin                 `xml:"Gateway-severityData,omitempty" json:"Gateway-severityData,omitempty" yaml:"Gateway-severityData,omitempty"`
	GatewaySnoozeData                   *GatewaySnoozeDataPlugin                   `xml:"Gateway-snoozeData,omitempty" json:"Gateway-snoozeData,omitempty" yaml:"Gateway-snoozeData,omitempty"`
	GatewaySQL                          *GatewaySQLPlugin                          `xml:"Gateway-sql,omitempty" json:"Gateway-sql,omitempty" yaml:"Gateway-sql,omitempty"`
	GatewayUserAssignmentData           *GatewayUserAssignmentDataPlugin           `` /* 130-byte string literal not displayed */

	// hardware-plugins.go
	CPU      *CPUPlugin      `xml:"cpu,omitempty" json:"cpu,omitempty" yaml:"cpu,omitempty"`
	Disk     *DiskPlugin     `xml:"disk,omitempty" json:"disk,omitempty" yaml:"disk,omitempty"`
	DeviceIO *DeviceIOPlugin `xml:"deviceio,omitempty" json:"deviceio,omitempty" yaml:"deviceio,omitempty"`
	Hardware *HardwarePlugin `xml:"hardware,omitempty" json:"hardware,omitempty" yaml:"hardware,omitempty"`
	Network  *NetworkPlugin  `xml:"network,omitempty" json:"network,omitempty" yaml:"hardware,omitempty"`

	// jmx-server.go
	JMXServer *JMXServerPlugin `xml:"jmx-server,omitempty" json:"jmx-server,omitempty" yaml:"jmx-server,omitempty"`

	// mq.go
	MQChannel *MQChannelPlugin `xml:"mq-channel,omitempty" json:"mq-channel,omitempty" yaml:"mq-channel,omitempty"`
	MQQInfo   *MQQInfoPlugin   `xml:"mq-qinfo,omitempty" json:"mq-qinfo,omitempty" yaml:"mq-qinfo,omitempty"`
	MQQueue   *MQQueuePlugin   `xml:"mq-queue,omitempty" json:"mq-queue,omitempty" yaml:"mq-queue,omitempty"`

	// perfmon.go
	Perfmon *PerfmonPlugin `xml:"perfmon,omitempty" json:"perfmon,omitempty" yaml:"perfmon,omitempty"`

	// processes.go
	Process *ProcessesPlugin `xml:"processes,omitempty" json:"processes,omitempty" yaml:"processes,omitempty"`

	// rest-api.go
	RESTAPI *RESTAPIPlugin `xml:"rest-api,omitempty" json:"rest-api,omitempty" yaml:"rest-api,omitempty"`

	// sql-toolkit.go
	SQLToolkit *SQLToolkitPlugin `xml:"sql-toolkit,omitempty" json:"sql-toolkit,omitempty" yaml:"sql-toolkit,omitempty"`

	// state-tracker.go
	StateTracker *StateTrackerPlugin `xml:"stateTracker,omitempty" json:"stateTracker,omitempty" yaml:"stateTracker,omitempty"`

	// tcp-links.go
	TCPLinks *TCPLinksPlugin `xml:"tcp-links,omitempty" json:"tcp-links,omitempty" yaml:"tcp-links,omitempty"`

	// toolkit.go
	Toolkit *ToolkitPlugin `xml:"toolkit,omitempty" json:"toolkit,omitempty" yaml:"toolkit,omitempty"`

	// top.go
	Top *TopPlugin `xml:"top,omitempty" json:"top,omitempty" yaml:"top,omitempty"`

	// unix-users.go
	UNIXUsers *UNIXUsersPlugin `xml:"unix-users,omitempty" json:"unix-users,omitempty" yaml:"unix-users,omitempty"`

	// web-mon.go
	WebMon *WebMonPlugin `xml:"web-mon,omitempty" json:"web-mon,omitempty" yaml:"web-mon,omitempty"`

	// win-services.go
	WinServices *WinServicesPlugin `xml:"win-services,omitempty" json:"win-services,omitempty" yaml:"win-services,omitempty"`

	// wmi.go
	WMI *WMIPlugin `xml:"wmi,omitempty" json:"wmi,omitempty" yaml:"wmi,omitempty"`

	// wts-sessions.go
	WTSSessions *WTSSessionsPlugin `xml:"wts-sessions,omitempty" json:"wts-sessions,omitempty" yaml:"wts-sessions,omitempty"`

	// x-ping.go
	XPing *XPingPlugin `xml:"x-ping,omitempty" json:"x-ping,omitempty" yaml:"x-ping,omitempty"`

	// unsupported - put config in 'Other'
	Other *UnsupportedPlugin `xml:",any" json:",omitempty" yaml:",omitempty"`
}

type Probe struct {
	XMLName   xml.Name `xml:"probe" json:"-" yaml:"-"`
	Type      int      `xml:"-" json:"-" yaml:"-"`
	Name      string   `xml:"name,attr" json:"name" yaml:"name"`
	Disabled  bool     `xml:"disabled,attr,omitempty" json:",omitempty" yaml:",omitempty"`
	Hostname  string   `xml:"hostname" json:"hostname" yaml:"hostname"`
	ProbeInfo `json:",inline" yaml:",inline" mapstructure:",squash"`
}

type ProbeGroup struct {
	XMLName        xml.Name `xml:"probeGroup" json:"-" yaml:"-"`
	Name           string   `xml:"name,attr"`
	Disabled       bool     `xml:"disabled,attr,omitempty" json:",omitempty" yaml:",omitempty"`
	ProbeInfo      `yaml:",inline" mapstructure:",squash"`
	ProbeGroups    []ProbeGroup    `xml:"probeGroup,omitempty" json:",omitempty" yaml:",omitempty" mapstructure:"probegroup"`
	Probes         []Probe         `xml:"probe,omitempty" json:",omitempty" yaml:",omitempty" mapstructure:"probe"`
	VirtualProbes  []VirtualProbe  `xml:"virtualProbe,omitempty" json:",omitempty" yaml:",omitempty" mapstructure:"virtualprobe"`
	FloatingProbes []FloatingProbe `xml:"floatingProbe,omitempty" json:",omitempty" yaml:",omitempty" mapstructure:"floatingprobe"`
}

type ProbeInfo struct {
	Port                 int   `xml:"port,omitempty" json:"port,omitempty" yaml:",omitempty" mapstructure:"port"`
	Secure               *bool `xml:"secure,omitempty" json:"secure,omitempty" yaml:",omitempty" mapstructure:"secure"`
	ProbeInfoWithoutPort `yaml:",inline" mapstructure:",squash"`
}

type ProbeInfoWithoutPort struct {
	CommandTimeOut         int `xml:",omitempty" json:",omitempty" yaml:",omitempty" mapstructure:"commandtimeout"`
	MaxDatabaseConnections int `xml:",omitempty" json:",omitempty" yaml:",omitempty" mapstructure:"maxdatabaseconnections"`
	MaxToolkitProcesses    int `xml:",omitempty" json:",omitempty" yaml:",omitempty" mapstructure:"maxtoolkitprocesses"`
}

type Probes struct {
	XMLName        xml.Name        `xml:"probes" json:"-" yaml:"-"`
	ProbeGroups    []ProbeGroup    `xml:"probeGroup,omitempty" json:",omitempty" yaml:",omitempty" mapstructure:"probegroup"`
	Probes         []Probe         `xml:"probe,omitempty" json:",omitempty" yaml:",omitempty" mapstructure:"probe"`
	VirtualProbes  []VirtualProbe  `xml:"virtualProbe,omitempty" json:",omitempty" yaml:",omitempty" mapstructure:"virtualprobe"`
	FloatingProbes []FloatingProbe `xml:"floatingProbe,omitempty" json:",omitempty" yaml:",omitempty" mapstructure:"floatingprobe"`
}

type Process struct {
	XMLName           xml.Name              `xml:"process" json:"-" yaml:"-"`
	Data              *ProcessDescriptor    `xml:"data,omitempty" json:",omitempty" yaml:",omitempty"`
	ProcessDescriptor *ProcessDescriptorRef `xml:"processDescriptor,omitempty" json:",omitempty" yaml:",omitempty"`
}

type ProcessDescriptor struct {
	// no struct XMLName as we can get here via two routes - "data" or "processDescriptor"
	// XMLName  xml.Name             `xml:"processDescriptor" json:"-" yaml:"-"`
	Name     string               `xml:"name,attr" json:"name" yaml:"name"`
	Disabled bool                 `xml:"disabled,attr,omitempty" json:",omitempty" yaml:",omitempty"`
	Alias    *SingleLineStringVar `xml:"alias" json:"alias" yaml:"alias"`
	Start    *SingleLineStringVar `xml:"start,omitempty" json:"start,omitempty" yaml:"start,omitempty"`
	Stop     *SingleLineStringVar `xml:"stop,omitempty" json:"stop,omitempty" yaml:"stop,omitempty"`
	LogFile  *SingleLineStringVar `xml:"logFile,omitempty" json:"logfile,omitempty" yaml:"logfile,omitempty"`
}

type ProcessDescriptorGroup struct {
	XMLName                 xml.Name                 `xml:"processDescriptorGroup" json:"-" yaml:"-"`
	Name                    string                   `xml:"name,attr" json:"name" yaml:"name"`
	Disabled                bool                     `xml:"disabled,attr,omitempty" json:",omitempty" yaml:",omitempty"`
	ProcessDescriptors      []ProcessDescriptor      `xml:"processDescriptor,omitempty" json:",omitempty" yaml:",omitempty"`
	ProcessDescriptorGroups []ProcessDescriptorGroup `xml:"processDescriptorGroup,omitempty" json:",omitempty" yaml:",omitempty"`
}

type ProcessDescriptorRef struct {
	Name string `xml:"ref,attr" json:"name" yaml:"name"`
}

type ProcessDescriptors struct {
	XMLName                 xml.Name                 `xml:"processDescriptors" json:"-" yaml:"-"`
	ProcessDescriptors      []ProcessDescriptor      `xml:"data,omitempty" json:",omitempty" yaml:",omitempty"`
	ProcessDescriptorGroups []ProcessDescriptorGroup `xml:"processDescriptorGroup,omitempty" json:",omitempty" yaml:",omitempty"`
}

type ProcessesPlugin struct {
	XMLName                     xml.Name  `xml:"processes" json:"-" yaml:"-"`
	AdjustForLogicalCPUs        *Value    `xml:"adjustForLogicalCPUs,omitempty" json:",omitempty" yaml:",omitempty"`
	AdjustForLogicalCPUsSummary *Value    `xml:"adjustForLogicalCPUsSummary,omitempty" json:",omitempty" yaml:",omitempty"`
	Processes                   []Process `xml:"processes>process,omitempty" json:",omitempty" yaml:",omitempty"`
}

type Query struct {
	Name *SingleLineStringVar `xml:"name"`
	SQL  *SingleLineStringVar `xml:"sql"`
}

type RESTAPIPlugin struct {
	XMLName xml.Name `xml:"rest-api" json:"-" yaml:"-"`
}

type Reference struct {
	Name string `xml:"ref,attr" json:",omitempty" yaml:",omitempty"`
}

type Regex struct {
	Regex string      `xml:"regex" json:"regex,omitempty" yaml:"regex,omitempty"`
	Flags *RegexFlags `xml:"flags,omitempty" json:"flags,omitempty" yaml:"flags,omitempty"`
}

type RegexFlags struct {
	CaseInsensitive *bool `xml:"i,omitempty" json:"i,omitempty" yaml:"i,omitempty"`
	DotMatchesAll   *bool `xml:"s,omitempty" json:"s,omitempty" yaml:"s,omitempty"`
}

type RemoveSamplers struct {
	XMLName  xml.Name          `xml:"removeSamplers" json:"-" yaml:"-"`
	Samplers []SamplerWithType `xml:"sampler,omitempty" json:",omitempty" yaml:",omitempty"`
}

type RemoveTypes struct {
	XMLName xml.Name  `xml:"removeTypes" json:"-" yaml:"-"`
	Types   []TypeRef `xml:"type,omitempty" json:",omitempty" yaml:",omitempty" mapstructure:"type"`
}

type Rule struct {
	XMLName      xml.Name `xml:"rule" json:"-" yaml:"-"`
	Name         string   `xml:"name,attr"`
	Targets      []string `xml:"targets>target"`
	Priority     int      `xml:"priority"`
	Ifs          []interface{}
	Transactions []interface{}
}

type RuleDefault struct {
	XMLName       xml.Name       `xml:"default,omitempty" json:"default,omitempty"`
	Name          string         `xml:"name,attr"`
	Contexts      []string       `xml:"rule>contexts>context,omitempty"`
	PriorityGroup *int           `xml:"priorityGroup,omitempty"`
	ActiveTime    *ActiveTimeRef `xml:"activeTime"`
}

type RuleGroup struct {
	XMLName    xml.Name      `xml:"ruleGroup" json:"-" yaml:"-"`
	Name       string        `xml:"name,attr"`
	Defaults   []RuleDefault `xml:"default,omitempty"`
	Rules      []Rule        `xml:"rule,omitempty" json:"rule,omitempty"`
	RuleGroups []RuleGroup   `xml:"ruleGroup,omitempty" json:"rulegroup,omitempty"`
}

type Rules struct {
	XMLName    xml.Name    `xml:"rules" json:"-" yaml:"-"`
	RuleGroups []RuleGroup `xml:"ruleGroup,omitempty" json:"rulegroup,omitempty"`
	Rules      []Rule      `xml:"rule,omitempty" json:"rule,omitempty"`
}

type SAManagedEntity struct {
	XMLName    xml.Name    `xml:"managedEntity"`
	Name       string      `xml:"name"`
	Attributes []Attribute `xml:"attributes,omitempty"`
	Vars       []Vars      `xml:"variables,omitempty"`
	Types      []PlainType `xml:"types,omitempty"`
}

type SQLServer struct {
	ServerName *SingleLineStringVar `xml:"var-serverName,omitempty"`
	DBName     *SingleLineStringVar `xml:"var-databaseName,omitempty"`
	Port       *SingleLineStringVar `xml:"var-port,omitempty"`
}

type SQLToolkitPlugin struct {
	XMLName    xml.Name     `xml:"sql-toolkit" json:"-" yaml:"-"`
	Queries    []Query      `xml:"queries>query"`
	Connection DBConnection `xml:"connection"`
}

type Sampler struct {
	XMLName                xml.Name                `xml:"sampler" json:"-" yaml:"-"`
	Name                   string                  `xml:"name,attr"`
	Disabled               bool                    `xml:"disabled,attr,omitempty" json:",omitempty" yaml:",omitempty"`
	Comment                string                  `xml:",comment" json:",omitempty" yaml:",omitempty"`
	Group                  *SingleLineStringVar    `xml:"var-group,omitempty" json:",omitempty" yaml:",omitempty"`
	Interval               *Value                  `xml:"sampleInterval,omitempty" json:",omitempty" yaml:",omitempty"`
	SampleOnStartup        bool                    `xml:"sampleOnStartup" json:",omitempty" yaml:",omitempty"`
	Plugin                 *Plugin                 `xml:"plugin,omitempty" json:"plugin,omitempty" yaml:"plugin,omitempty"`
	Dataviews              *[]Dataview             `xml:"dataviews>dataview,omitempty" json:",omitempty" yaml:",omitempty"`
	Schemas                *Schemas                `xml:"schemas,omitempty" json:",omitempty" yaml:",omitempty"`
	StandardisedFormatting *StandardisedFormatting `xml:"standardisedFormatting,omitempty" json:",omitempty" yaml:",omitempty"`
}

type SamplerGroup struct {
	XMLName       xml.Name       `xml:"samplerGroup" json:"-" yaml:"-"`
	Name          string         `xml:"name,attr"`
	Disabled      bool           `xml:"disabled,attr,omitempty" json:",omitempty" yaml:",omitempty"`
	Samplers      []Sampler      `xml:"sampler,omitempty" json:",omitempty" yaml:",omitempty" mapstructure:"sampler"`
	SamplerGroups []SamplerGroup `xml:"samplerGroup,omitempty" json:",omitempty" yaml:",omitempty" mapstructure:"samplergroup"`
}

type SamplerRef struct {
	XMLName  xml.Name `xml:"sampler" json:"-" yaml:"-"`
	Name     string   `xml:"ref,attr" json:",omitempty" yaml:",omitempty"`
	Disabled bool     `xml:"disabled,attr,omitempty" json:",omitempty" yaml:",omitempty"`
}

type SamplerWithType struct {
	XMLName xml.Name `xml:"sampler" json:"-" yaml:"-"`
	Sampler string   `xml:"ref,attr"`
	Type    TypeRef  `xml:"type"`
}

type Samplers struct {
	XMLName       xml.Name       `xml:"samplers" json:"-" yaml:"-"`
	Samplers      []Sampler      `xml:"sampler,omitempty" json:",omitempty" yaml:",omitempty" mapstructure:"sampler"`
	SamplerGroups []SamplerGroup `xml:"samplerGroup,omitempty" json:",omitempty" yaml:",omitempty" mapstructure:"samplergroup"`
}

type Schema struct {
	Headlines *[]SchemaTypedItem `xml:"headlines>headline,omitempty"`
	Columns   *[]SchemaTypedItem `xml:"columns>column,omitempty"`
	Pivot     bool               `xml:"pivot,omitempty"`
	Publish   bool               `xml:"publish"`
}

type SchemaTypedItem struct {
	Name     string         `xml:"name"`
	String   *EmptyStruct   `xml:"string,omitempty"`
	Boolean  *EmptyStruct   `xml:"boolean,omitempty"`
	Float32  *UnitOfMeasure `xml:"float32,omitempty"`
	Float64  *UnitOfMeasure `xml:"float64,omitempty"`
	Int32    *UnitOfMeasure `xml:"int32,omitempty"`
	Int64    *UnitOfMeasure `xml:"int64,omitempty"`
	Date     *EmptyStruct   `xml:"date,omitempty"`
	DateTime *EmptyStruct   `xml:"dateTime,omitempty"`
}

type Schemas struct {
	Dataviews *[]DataviewSchema `xml:"dataviews>dataviewSchema,omitempty"`
}

type SelfAnnounce struct {
	Enabled                  bool              `xml:"enabled"`
	RetryInterval            int               `xml:"retryInterval,omitempty"`
	RequireReverseConnection bool              `xml:"requireReverseConnection,omitempty"`
	ProbeName                string            `xml:"probeName"`
	EncodedPassword          string            `xml:"encodedPassword,omitempty"`
	RESTAPIHTTPPort          int               `xml:"restApiHttpPort,omitempty"`
	RESTAPIHTTPSPort         int               `xml:"restApiHttpsPort,omitempty"`
	CyberArkApplicationID    string            `xml:"cyberArkApplicationID,omitempty"`
	CyberArkSDKPath          string            `xml:"cyberArkSdkPath,omitempty"`
	ManagedEntity            *SAManagedEntity  `xml:"managedEntity,omitempty"`
	ManagedEntities          []SAManagedEntity `xml:"managedEntities,omitempty"`
	CollectionAgent          *CollectionAgent  `xml:"collectionAgent,omitempty"`
	DynamicEntities          *DynamicEntities  `xml:"dynamicEntities,omitempty"`
	Gateways                 []Gateways        `xml:"gateways"`
}

type Service struct {
	ServiceName        *ServiceName        `xml:"serviceName,omitempty" json:"name,omitempty" yaml:"name,omitempty"`
	ServiceDescription *ServiceDescription `xml:"serviceDescription,omitempty" json:"description,omitempty" yaml:"description,omitempty"`
}

type ServiceDescription struct {
	Basic *SingleLineStringVar `xml:"basic>pattern,omitempty" json:"basic,omitempty" yaml:"basic,omitempty"`
	Regex *Regex               `xml:"regex,omitempty" json:"regex,omitempty" yaml:"regex,omitempty"`
}

type ServiceName struct {
	Basic                *SingleLineStringVar `xml:"basic>pattern,omitempty" json:"basic,omitempty" yaml:"basic,omitempty"`
	BasicShowUnavailable bool                 `xml:"basic>showIfUnavailable,omitempty" json:"showIfUnavailable,omitempty" yaml:"showIfUnavailable,omitempty"`
	Regex                *Value               `xml:"regex,omitempty" json:"regex,omitempty" yaml:"regex,omitempty"`
}

type SingleLineStringVar struct {
	Parts []interface{}
}

type StandardisedFormatting struct {
	Dataviews []StandardisedFormattingDataview `xml:"dataviews>dataview,omitempty" json:",omitempty" yaml:",omitempty"`
}

type StandardisedFormattingApplicability struct {
	Headlines []Regex                      `xml:"headlines>pattern,omitempty"`
	Columns   []Regex                      `xml:"columns>pattern,omitempty"`
	Cells     []StandardisedFormattingCell `xml:"cells>cell,omitempty"`
}

type StandardisedFormattingCell struct {
	Row    string `xml:"row"`
	Column string `xml:"column"`
}

type StandardisedFormattingDataview struct {
	Name      string                           `xml:"name"` // do not omitempty
	Variables []StandardisedFormattingVariable `xml:"variables>variable"`
}

type StandardisedFormattingDateTime struct {
	Formats                   []string `xml:"formats>format,omitempty"`
	Exceptions                []string `xml:"exceptions,omitempty"`
	IgnoreErrorsIfFormatFails bool     `xml:"ignoreErrorsIfFormatsFail,omitempty"`
	OverrideTimezone          string   `xml:"overrideTimezone,omitempty"`
}

type StandardisedFormattingType struct {
	DateTime *StandardisedFormattingDateTime `xml:"dateTime"`
}

type StandardisedFormattingVariable struct {
	Type          *StandardisedFormattingType          `xml:"type"`
	Applicability *StandardisedFormattingApplicability `xml:"applicability"`
}

type StateTrackerColumns struct {
	RenameTrackerColumn *SingleLineStringVar   `xml:"renameTrackerColumn"`
	Columns             []*SingleLineStringVar `xml:"column"`
}

type StateTrackerGroup struct {
	Name     string                 `xml:"name,attr"`
	Trackers []*StateTrackerTracker `xml:"trackers>tracker,omitempty"`
}

type StateTrackerPerformance struct {
	SkipMidsampleUpdates   *Value `xml:"skipMidSampleUpdates,omitempty"`
	MaxMessagesPerSample   *Value `xml:"maxMessagesPerSample,omitempty"`
	MinimumReservedRowpace *Value `xml:"minimumReservedRowspace,omitempty"`
}

type StateTrackerPlugin struct {
	XMLName         xml.Name                     `xml:"stateTracker" json:"-" yaml:"-"`
	Columns         StateTrackerColumns          `xml:"columns"`
	TemplateOptions *StateTrackerTemplateOptions `xml:"templateOptions,omitempty"`
	Performance     *StateTrackerPerformance     `xml:"performance,omitempty"`
	TrackerGroup    []StateTrackerGroup          `xml:"trackerGroup,omitempty"`
}

type StateTrackerTemplateOptions struct {
	HideTrackerIDs *Value `xml:"hideTrackerIDs"`
}

type StateTrackerTracker struct {
	// XMLName        xml.Name             `xml:"tracker" json:"-" yaml:"-"`
	DeprecatedName string               `xml:"name,attr"`
	Name           *SingleLineStringVar `xml:"name"`
	Filename       *SingleLineStringVar `xml:"filename"`
	Stream         *SingleLineStringVar `xml:"stream"`
	Rewind         *Value               `xml:"rewind"`
	Template       *Value               `xml:"template"`
}

type Streams struct {
	XMLName xml.Name               `xml:"streams" json:"-" yaml:"-"`
	Stream  []*SingleLineStringVar `xml:"stream"`
}

type StringList struct {
	Strings []string `xml:"string" mapstructure:"string"`
}

type Sybase struct {
	InterfaceEntry  *SingleLineStringVar `xml:"var-interfaceEntry,omitempty"`
	DBName          *SingleLineStringVar `xml:"var-databaseName,omitempty"`
	ApplicationName *SingleLineStringVar `xml:"var-applicationName,omitempty"`
}

type TCPLinksPlugin struct {
	XMLName      xml.Name              `xml:"tcp-links" json:"-" yaml:"-"`
	LocalPorts   []SingleLineStringVar `xml:"localPorts>port,omitempty" json:"localPorts,omitempty" yaml:"localPorts,omitempty"`
	RemotePorts  []SingleLineStringVar `xml:"remotePorts>port,omitempty" json:"remotePorts,omitempty" yaml:"remotePorts,omitempty"`
	Command      *SingleLineStringVar  `xml:"command,omitempty" json:"command,omitempty" xml:"command,omitempty"`
	NameContents *NameContents         `xml:"nameContents,omitempty" json:"nameContents,omitempty" yaml:"nameContents,omitempty"`
}

type ToolkitPlugin struct {
	XMLName              xml.Name               `xml:"toolkit" json:"-" yaml:"-"`
	SamplerScript        *SingleLineStringVar   `xml:"samplerScript"`
	SamplerTimeout       *Value                 `xml:"scriptTimeout,omitempty"`
	EnvironmentVariables *[]EnvironmentVariable `xml:"environmentVariables>variable"`
}

type TopPlugin struct {
	XMLName xml.Name `xml:"top" json:"-" yaml:"-"`
}

type Type struct {
	XMLName     xml.Name     `xml:"type" json:"-" yaml:"-"`
	Name        string       `xml:"name,attr"`
	Disabled    bool         `xml:"disabled,attr,omitempty" json:",omitempty" yaml:",omitempty"`
	Environment *Reference   `xml:"environment,omitempty" json:",omitempty" yaml:",omitempty"`
	Vars        []Vars       `xml:"var,omitempty" json:",omitempty" yaml:",omitempty" mapstructure:"var"`
	Samplers    []SamplerRef `xml:"sampler,omitempty" json:",omitempty" yaml:",omitempty" mapstructure:"sampler"`
}

type TypeGroup struct {
	XMLName    xml.Name    `xml:"typeGroup" json:"-" yaml:"-"`
	Name       string      `xml:"name,attr"`
	Disabled   bool        `xml:"disabled,attr,omitempty" json:",omitempty" yaml:",omitempty"`
	Types      []Type      `xml:"type,omitempty" json:",omitempty" yaml:",omitempty" mapstructure:"type"`
	TypeGroups []TypeGroup `xml:"typeGroup,omitempty" json:"typeGroup,omitempty" yaml:",omitempty" mapstructure:"typegroup"`
}

type TypeRef struct {
	XMLName xml.Name `xml:"type" json:"-" yaml:"-"`
	Type    string   `xml:"ref,attr" json:",omitempty" yaml:",omitempty" mapstructure:"ref"`
}

type TypeRefWithEnv struct {
	XMLName     xml.Name        `xml:"type" json:"-" yaml:"-"`
	Type        string          `xml:"ref,attr" json:",omitempty" yaml:",omitempty" mapstructure:"ref"`
	Environment *EnvironmentRef `xml:",omitempty" json:",omitempty" yaml:",omitempty"`
}

type Types struct {
	XMLName    xml.Name    `xml:"types" json:"-" yaml:"-"`
	Types      []Type      `xml:"type,omitempty" json:",omitempty" yaml:",omitempty" mapstructure:"type"`
	TypeGroups []TypeGroup `xml:"typeGroup,omitempty" json:"typeGroup,omitempty" yaml:",omitempty" mapstructure:"typegroup"`
}

type UNIXUsersPlugin struct {
	XMLName xml.Name `xml:"unix-users" json:"-" yaml:"-"`
}

type UOM string

type UnitOfMeasure struct {
	Unit UOM `xml:"unitOfMeasure"`
}

type UnsupportedPlugin struct {
	XMLName xml.Name
	RawXML  string `xml:",innerxml" json:",omitempty" yaml:",omitempty"`
}

type Value struct {
	Data   *Data  `xml:"data,omitempty" json:",omitempty" yaml:",omitempty"`
	Var    *Var   `xml:"var,omitempty" json:",omitempty" yaml:",omitempty"`
	ExtPwd string `xml:"extPwd,omitempty" json:",omitempty" yaml:",omitempty"`
	StdAES string `xml:"stdAES,omitempty" json:",omitempty" yaml:",omitempty"`
}

type Var struct {
	XMLName xml.Name `xml:"var" json:"-" yaml:"-"`
	Var     string   `xml:"ref,attr"`
}

type Vars struct {
	XMLName       xml.Name       `xml:"var" json:"-" yaml:"-"`
	Name          string         `xml:"name,attr"`
	Boolean       *bool          `xml:"boolean,omitempty" json:",omitempty" yaml:",omitempty"`
	Double        *float64       `xml:"double,omitempty" json:",omitempty" yaml:",omitempty"`
	Integer       *int64         `xml:"integer,omitempty" json:",omitempty" yaml:",omitempty"`
	String        string         `xml:"string,omitempty" json:",omitempty" yaml:",omitempty"`
	StringList    *StringList    `xml:"stringList,omitempty" json:",omitempty" yaml:",omitempty"`
	NameValueList *NameValueList `xml:"nameValueList,omitempty" json:",omitempty" yaml:",omitempty"`
	Macro         *Macro         `xml:"macro,omitempty" json:",omitempty" yaml:",omitempty"`
	Regex         *Regex         `xml:"regex,omitempty" json:",omitempty" yaml:",omitempty"`
}

type VirtualProbe struct {
	XMLName  xml.Name `xml:"virtualProbe" json:"-" yaml:"-"`
	Name     string   `xml:"name,attr" json:"name" yaml:"name"`
	Disabled bool     `xml:"disabled,attr,omitempty" json:",omitempty" yaml:",omitempty"`
}

type WMIPlugin struct{}

type WTSSessionsPlugin struct {
	XMLName xml.Name `xml:"wts-sessions" json:"-" yaml:"-"`
}

type WebMonPlugin struct {
	XMLName xml.Name `xml:"web-mon" json:"-" yaml:"-"`
}

type WinServicesPlugin struct {
	XMLName     xml.Name              `xml:"win-services" json:"-" yaml:"-"`
	ServicesOld []SingleLineStringVar `xml:"services,omitempty" json:"servicesOld,omitempty" yaml:"servicesOld,omitempty"`
	Services    []Service             `xml:"servicesNew>service,omitempty" json:"services,omitempty" yaml:"services,omitempty"`
}

type XPingPlugin struct {
	XMLName           xml.Name   `xml:"x-ping" json:"-" yaml:"-"`
	TargetNodes       []Host     `xml:"targetNodes>targetNode,omitempty" json:"targetNode,omitempty" yaml:"targetNode,omitempty"`
	RecvInterfacesVar *Reference `xml:"recvInterfaces>var,omitempty" json:"recvInterfaceVar,omitempty" yaml:"recvInterfaceVar,omitempty"`
	RecvInterfaces    []Value    `xml:"recvInterfaces>data>recvInterface,omitempty" json:"recvInterface,omitempty" yaml:"recvInterface,omitempty"`
	SendInterface     *Value     `xml:"sendInterface" json:"sendInterface" yaml:"sendInterface"`
}