connect

type ABExtension struct {
	GroupId string `json:"groupId"`
	Label   string `json:"label"`
}

type AboutInfo struct {
	CurrentUsers    int              `json:"currentUsers"`    // number of created users on domain
	AllowedUsers    MaximumUsers     `json:"allowedUsers"`    // number of allowed users, take stricter limit from max. number for domain, max. number by license
	ServerSoftware  string           `json:"serverSoftware"`  // product name and version string, same as SERVER_SOFTWARE
	Subscription    SubscriptionInfo `json:"subscription"`    // information about subscription
	Copyright       string           `json:"copyright"`       // copyright string
	ProductHomepage string           `json:"productHomepage"` // url to homepage of product
}

type AccessPolicyConnectionRule struct {
	Type    AccessPolicyConnectionRuleType `json:"type"`    // type of rule
	GroupId KId                            `json:"groupId"` // if type of rule is 'ServiceIpAllowed/Denied' there is ID of IP Group
}

type AccessPolicyConnectionRuleType string

type AccessPolicyGroup struct {
	Id        KId    `json:"id"`        // [READ-ONLY] [REQUIRED FOR SET] global identification
	Name      string `json:"name"`      // name of policy
	IsDefault bool   `json:"isDefault"` // [READ-ONLY]
}

type AccessPolicyGroupList []AccessPolicyGroup

type AccessPolicyRule struct {
	Id      KId                        `json:"id"`      // [READ-ONLY] [REQUIRED FOR SET] global identification
	GroupId KId                        `json:"groupId"` // [REQUIRED FOR CREATE] global identification of AccessPolicyGroup
	Service ServiceType                `json:"service"` // type of service
	Rule    AccessPolicyConnectionRule `json:"rule"`    // rule for connections
}

type AccessPolicyRuleList []AccessPolicyRule

type ActionAfterDays struct {
	IsEnabled bool `json:"isEnabled"` // is action on/off?
	Days      int  `json:"days"`      // after how many days is an action performed?
}

type AddResult struct {
	Id           KId                `json:"id"`           // purposely not id - loginName is shown
	Success      bool               `json:"success"`      // was operation successful? if yes so id is new id for this item else errorMessage tells why it failed
	ErrorMessage LocalizableMessage `json:"errorMessage"` // contains number of recovered user messages or error message
}

type AddResultList []AddResult

type AdditionalFiles []string

type AdditionalInfo struct {
	IsEnabled bool   `json:"isEnabled"` // Is used
	Text      string `json:"text"`
}

type AddressType string

type Administration struct {
	IsEnabled                   bool   `json:"isEnabled"`                   // administration from other that local machine is enabled/disabled
	IsLimited                   bool   `json:"isLimited"`                   // administration is limited
	GroupId                     KId    `json:"groupId"`                     // IP Address Group identifier on which is limit applied
	GroupName                   string `json:"groupName"`                   // [READ-ONLY] IP Address Group name on which is limit applied
	BuiltInAdminEnabled         bool   `json:"builtInAdminEnabled"`         // if is enabled field builtInAdminPassword is required
	BuiltInAdminUsername        string `json:"builtInAdminUsername"`        // [READ-ONLY] user name
	BuiltInAdminPassword        string `json:"builtInAdminPassword"`        // password
	BuiltInAdminPasswordIsEmpty bool   `json:"builtInAdminPasswordIsEmpty"` // [READ-ONLY] password is empty
	BuiltInAdminUsernameCollide bool   `json:"builtInAdminUsernameCollide"` // [READ-ONLY] username colide with user in primary domain
}

type AdvancedOptionsSetting struct {
	Miscellaneous        MiscellaneousOptions        `json:"miscellaneous"`
	StoreDirectory       StoreDirectoryOptions       `json:"storeDirectory"`
	MasterAuthentication MasterAuthenticationOptions `json:"masterAuthentication"`
	HttpProxy            HttpProxyOptions            `json:"httpProxy"`
	UpdateChecker        UpdateCheckerOptions        `json:"updateChecker"`
	WebMail              WebMailOptions              `json:"webMail"`
	UserQuota            UserQuota                   `json:"userQuota"`
	Fulltext             FulltextSetting             `json:"fulltext"`
	KoffOptions          KoffOptions                 `json:"koffOptions"`
	OperatorOptions      OperatorOptions             `json:"operatorOptions"`
}

type Alert struct {
	AlertName     AlertName `json:"alertName"`     // Alert Id
	AlertType     TypeAlert `json:"alertType"`     // Alert type
	CurrentValue  string    `json:"currentValue"`  // Current Value
	CriticalValue string    `json:"criticalValue"` // Critical Value
}

type AlertList []Alert

type AlertName string

type Alias struct {
	Id          KId        `json:"id"`          // global identification of alias
	DomainId    KId        `json:"domainId"`    // [REQUIRED FOR CREATE] identification in which domain alias exists
	Name        string     `json:"name"`        // [REQUIRED FOR CREATE] [USED BY QUICKSEARCH] left side of alias
	DeliverToId KId        `json:"deliverToId"` // empty if email or contains public folder kid
	DeliverTo   string     `json:"deliverTo"`   // [REQUIRED FOR CREATE] [USED BY QUICKSEARCH] email address or public folder name
	Type        AliasType  `json:"type"`        // type of the alias
	Description string     `json:"description"` // description
	HomeServer  HomeServer `json:"homeServer"`  // [READ-ONLY] Id of alias homeserver if server is in Cluster
}

type AliasList []Alias

type AliasTarget struct {
	Id           KId             `json:"id"`           // unique identifier
	Type         AliasTargetType `json:"type"`         // item type discriminator
	Name         string          `json:"name"`         // loginName for the User, name in square brackets for the Group
	FullName     string          `json:"fullName"`     // fullname for the User, empty string for the Group
	Description  string          `json:"description"`  // description of User/Group
	IsEnabled    bool            `json:"isEnabled"`    // is the User/Group enabled?
	ItemSource   DataSource      `json:"itemSource"`   // is the User/Group stored internally or by LDAP?
	EmailAddress string          `json:"emailAddress"` // first email address
	HomeServer   HomeServer      `json:"homeServer"`   // id of users homeserver if server is in Cluster; groups haven't homeserver
}

type AliasTargetList []AliasTarget

type AliasTargetType string

type AliasType string

type AntiHammeringOptions struct {
	IsEnabled           bool           `json:"isEnabled"`           // Enable/disable Anti-Hammering
	FailedLoginsToBlock int            `json:"failedLoginsToBlock"` // Count of failed logins within minute to start blocking
	MinutesToBlock      int            `json:"minutesToBlock"`      // Minutes to keep blocking IP
	ExceptionIpGroup    OptionalEntity `json:"exceptionIpGroup"`    // switchable custom white list IP group
}

type AntiSpamSetting struct {
	IsRatingEnabled           bool                     `json:"isRatingEnabled"`      // is spam filter rating enabled?
	IsRatingRelayEnabled      bool                     `json:"isRatingRelayEnabled"` // is rating of messages sent from trustworthy relay agents enabled?
	TagScore                  int                      `json:"tagScore"`
	BlockScore                int                      `json:"blockScore"`
	SubjectPrefix             OptionalString           `json:"subjectPrefix"`           // SPAM is marked with this prefix
	SendBounce                bool                     `json:"sendBounce"`              // send bounce message to the sender of SPAM?
	QuarantineAddress         OptionalString           `json:"quarantineAddress"`       // forward SPAM to a Quarantine address?
	CustomWhiteList           OptionalEntity           `json:"customWhiteList"`         // switchable custom white list IP group
	CustomBlackList           BlackListSetting         `json:"customBlackList"`         // switchable custom blacklist list IP group
	SendBounceCustom          bool                     `json:"sendBounceCustom"`        // send bounce message to the sender if rejection was done by custom rule(s)?
	QuarantineAddressCustom   OptionalString           `json:"quarantineAddressCustom"` // forward custom rules identified SPAM to a Quarantine address?
	UseSurbl                  bool                     `json:"useSurbl"`                // use Spam URI Realtime Block List database?
	FilterStatus              BayesState               `json:"filterStatus"`            // read only: Bayesian filter status
	LearnedAsSpam             int                      `json:"learnedAsSpam"`           // read only: number of messages that Bayesian filter learned as Spam
	LearnedAsNotSpam          int                      `json:"learnedAsNotSpam"`        // read only: number of messages that Bayesian filter learned as NOT a Spam
	IsCustomSigningKey        bool                     `json:"isCustomSigningKey"`      // Custom signing key is used for DKIM validation
	CallerSetting             CallerId                 `json:"callerSetting"`           // Caller ID setting
	CallerUrl                 string                   `json:"callerUrl"`               // read only: Caller ID URL with detailed info
	SpfSetting                Spf                      `json:"spfSetting"`              // Sender Policy Framework setting
	RepellentSetting          Repellent                `json:"repellentSetting"`
	GreylistingStatus         Greylisting              `json:"greylistingStatus"`
	UseCustomRulesInSmtp      bool                     `json:"useCustomRulesInSmtp"`      //
	IntegratedAntiSpamSetting IntegratedAntiSpamEngine `json:"integratedAntiSpamSetting"` // Kerio Anti-Spam
}

type AntibombingStats struct {
	RejectedConnections    string `json:"rejectedConnections"`
	RejectedMessages       string `json:"rejectedMessages"`
	RejectedHarvestAttacks string `json:"rejectedHarvestAttacks"`
}

type AntivirusOption struct {
	Name         string `json:"name"`
	Content      string `json:"content"`
	DefaultValue string `json:"defaultValue"` // read only value
}

type AntivirusOptionList []AntivirusOption

type AntivirusPlugin struct {
	Id                  string              `json:"id"`          // example: avir_avg
	Description         string              `json:"description"` // example: AVG Email Server Edition
	AreOptionsAvailable bool                `json:"areOptionsAvailable"`
	Options             AntivirusOptionList `json:"options"`
}

type AntivirusPluginList []AntivirusPlugin

type AntivirusSetting struct {
	UseIntegrated      bool                 `json:"useIntegrated"`      // integrated antivirus is used?
	UseExternal        bool                 `json:"useExternal"`        // an external antivirus is used? note: both internal and extenal can be used together
	Status             AntivirusStatus      `json:"status"`             // status of antivirus to be used for informative massage
	Plugins            AntivirusPluginList  `json:"plugins"`            // list of available antivirus plugins
	SelectedId         string               `json:"selectedId"`         // identifier of currently selected antivirus plugin
	Engine             IntegratedEngine     `json:"engine"`             // integrated engine settings
	VirusReaction      FoundVirusBehavior   `json:"virusReaction"`      // found virus reaction setting
	NotScannedReaction ReactionOnNotScanned `json:"notScannedReaction"` // found corruption or encryption reaction type
}

type AntivirusStats struct {
	CheckedAttachments string `json:"checkedAttachments"` // how many checked attachments
	FoundViruses       string `json:"foundViruses"`       // how many found viruses
	ProhibitedTypes    string `json:"prohibitedTypes"`    // how many found prohibited filenames/MIME types
}

type AntivirusStatus string

type ApiApplication struct {
	Name    string `json:"name"`    // E.g. "Simple server monitor"
	Vendor  string `json:"vendor"`  // E.g. "MyScript Ltd."
	Version string `json:"version"` // E.g. "1.0.0 beta 1"
}

type ApiVersion int

type ArchiveOptions struct {
	Paths                     Directories        `json:"paths"`                     // Paths to store/archive/backup
	IsEnabled                 bool               `json:"isEnabled"`                 // Enable mail archiving
	RemoteArchive             OptionalString     `json:"remoteArchive"`             // Archive to remote email address
	ArchiveToLocalFolder      bool               `json:"archiveToLocalFolder"`      // Archive to local folder
	ArchiveFoldersInterval    DayWeekMonthPeriod `json:"archiveFoldersInterval"`    // Interval used for creating of new archive folders (in days/weeks/months)
	CompressOldArchiveFolders bool               `json:"compressOldArchiveFolders"` // Compress old archive folders
	CompressionStartTime      Time               `json:"compressionStartTime"`      // Time in the day when an archive compression shall start
	ArchiveLocalMessages      bool               `json:"archiveLocalMessages"`      // Local messages (local sender, local recipient)
	ArchiveIncomingMessages   bool               `json:"archiveIncomingMessages"`   // Incoming messages (remote sender, local recipient)
	ArchiveOutgoingMessages   bool               `json:"archiveOutgoingMessages"`   // Outgoing messages (local sender, remote recipient)
	ArchiveRelayedMessages    bool               `json:"archiveRelayedMessages"`    // Relayed messages (remote sender, remote recipient)
	ArchiveBeforeFilter       bool               `json:"archiveBeforeFilter"`       // Archive messages before content filter check (viruses and spams will be stored intact in the archive folders)
	IsXmppEnabled             bool               `json:"isXmppEnabled"`             // Enable archiving for instant messaging
	IsEnabledPerDomain        bool               `json:"isEnabledPerDomain"`        // Enable custom per domain settings
}

type ArchiveSettings struct {
	KeepArchive          bool        `json:"keepArchive"`          // maintain archive
	ArchiveOnlyForLogged bool        `json:"archiveOnlyForLogged"` // the archive is available for logged users only
	ArchiveReaderList    TrusteeList `json:"archiveReaderList"`    // list of archive readers, can be either user or group, meaningful only if onlyForLogged is true
}

type AttachmentAction string

type AttachmentItem struct {
	Id          KId              `json:"id"`
	Enabled     bool             `json:"enabled"`     // the rule is in use
	Type        AttachmentType   `json:"type"`        // type of the rule
	Content     string           `json:"content"`     // *,? wildcards are supported
	Action      AttachmentAction `json:"action"`      // what to do if the rule maches
	Description string           `json:"description"` //
}

type AttachmentItemList []AttachmentItem

type AttachmentSetting struct {
	Enabled                bool           `json:"enabled"`                // attachment filter is on/off
	WarnSender             bool           `json:"warnSender"`             // sender will (not) obtain warning message
	ForwardOriginal        OptionalString `json:"forwardOriginal"`        // where to forward original message
	ForwardFiltered        OptionalString `json:"forwardFiltered"`        // where to forward filtered message
	EnableZipContentFilter bool           `json:"enableZipContentFilter"` // checks zip content for prohibited extennsions
}

type AttachmentType string

type AuthResult string

type AuthTypeList []UserAuthType

type AuthenticationMethodList []OptionalString

type BackupInfo struct {
	IsCreated bool               `json:"isCreated"` // True, if backup was successfully created
	Created   UtcDateTime        `json:"created"`   // Time when backup started (always in GTM)
	Size      ByteValueWithUnits `json:"size"`      // Compressed size of a backup
}

type BackupOptions struct {
	Paths                    Directories  `json:"paths"`                    // Paths to store/archive/backup, this field is used in both, archive and backup, options
	IsEnabled                bool         `json:"isEnabled"`                // Enable message store and configuration recovery backup
	Status                   BackupStatus `json:"status"`                   // Current backup status
	SplitSizeLimit           int          `json:"splitSizeLimit"`           // Split backup files if size reaches 'splitSizeLimit' (MB)
	RotationLimit            int          `json:"rotationLimit"`            // Keep at most 'rotationLimit' complete backups
	NetworkDiskUserName      string       `json:"networkDiskUserName"`      // If the backup directory is on the network disk, you may need to specify user name
	NetworkDiskPassword      string       `json:"networkDiskPassword"`      // ... and password
	NotificationEmailAddress string       `json:"notificationEmailAddress"` // An email address of person that will be notified when backup is completed or if any problems arise
}

type BackupSchedule struct {
	Id          KId        `json:"id"`          // [READ-ONLY]
	IsEnabled   bool       `json:"isEnabled"`   // True if backup schedule is enabled
	Type        BackupType `json:"type"`        // Backup type
	DayType     DayType    `json:"day"`         // Backup schedule day of week
	Time        TimeHMS    `json:"time"`        // Backup schedule start time - days are ignored!
	Description string     `json:"description"` // description of the backup schedule
}

type BackupScheduleList []BackupSchedule

type BackupStatus struct {
	BackupInProgress bool             `json:"backupInProgress"` // True, if backup is in progress; otherwise, false
	Percents         int              `json:"percents"`         // Backup progress in percents (form 0 to 100)
	LastBackupStatus LastBackupStatus `json:"lastBackupStatus"` // Status of the last backup run
	ElapsedTime      Distance         `json:"elapsedTime"`      // Time from last started backup
	RemainingTime    Distance         `json:"remainingTime"`    // Approximated time to end of current backup
	LastFull         BackupInfo       `json:"lastFull"`         // Information about last full backup
	LastDifferential BackupInfo       `json:"lastDifferential"` // Information about last differential backup
	LastMirror       BackupInfo       `json:"lastMirror"`       // Information about last mirror backup
}

type BackupType string

type BayesState string

type BlackList struct {
	Id          KId          `json:"id"` // global identifier
	Enabled     bool         `json:"enabled"`
	DnsSuffix   string       `json:"dnsSuffix"`
	Description string       `json:"description"`
	Action      BlockOrScore `json:"action"` // what to do if IP address is found on blacklist
	Score       int          `json:"score"`
	AskDirectly bool         `json:"askDirectly"`
}

type BlackListList []BlackList

type BlackListSetting struct {
	Enabled bool         `json:"enabled"`
	Id      KId          `json:"id"` // global identifier
	Name    string       `json:"name"`
	Action  BlockOrScore `json:"action"`
	Score   int          `json:"score"`
}

type BlockOrScore string

type BuildType string

type ButtonColor struct {
	IsEnabled       bool   `json:"isEnabled"` // Is used
	TextColor       string `json:"textColor"`
	BackgroundColor string `json:"backgroundColor"`
}

type ByteUnits string

type ByteValueWithUnits struct {
	Value int       `json:"value"`
	Units ByteUnits `json:"units"`
}

type CallerId struct {
	Enabled          bool           `json:"enabled"`
	Action           SpamAction     `json:"action"`
	Score            int            `json:"score"`
	ApplyOnTesting   bool           `json:"applyOnTesting"`
	ExceptionIpGroup OptionalEntity `json:"exceptionIpGroup"` // switchable custom white list IP group
}

type Certificate struct {
	Id                         KId                 `json:"id"`
	Status                     StoreStatus         `json:"status"`
	Name                       string              `json:"name"`
	Issuer                     NamedValueList      `json:"issuer"`
	Subject                    NamedValueList      `json:"subject"`
	SubjectAlternativeNameList NamedMultiValueList `json:"subjectAlternativeNameList"`
	Fingerprint                string              `json:"fingerprint"`       // 128-bit MD5, i.e. 16 hexa values separated by colons
	FingerprintSha1            string              `json:"fingerprintSha1"`   // 160-bit SHA1, i.e. 20 hexa values separated by colons
	FingerprintSha256          string              `json:"fingerprintSha256"` // 512-bit SHA256, i.e. 64 hexa values separated by colons
	ValidPeriod                ValidPeriod         `json:"validPeriod"`
	Valid                      bool                `json:"valid"` // exists and valid content
	Type                       CertificateType     `json:"type"`
	IsUntrusted                bool                `json:"isUntrusted"`
	VerificationMessage        string              `json:"verificationMessage"`
	ChainInfo                  StringList          `json:"chainInfo"`
	IsSelfSigned               bool                `json:"isSelfSigned"`
}

type CertificateList []Certificate

type CertificateType string

type Chart struct {
	Classname  string    `json:"classname"`  // A class name of chart
	Name       string    `json:"name"`       // A chart name
	Xtype      string    `json:"xtype"`      // An x scale type
	Ytype      string    `json:"ytype"`      // An y scale type
	ScaleCount int       `json:"scaleCount"` // A count of scales
	Scale      ScaleList `json:"scale"`      // List of scales
}

type ChartData struct {
	XName       string             `json:"xName"`       // Name of X axis
	XValues     ChartValueList     `json:"xValues"`     // Values of X axis
	CountValues int                `json:"countValues"` // A count of values in X axis
	CountRows   int                `json:"countRows"`   // A count of rows
	RowNames    ChartRowNamesList  `json:"rowNames"`    // Array of names of rows
	RowValues   ChartRowValuesList `json:"rowValues"`   // Array of values of rows
}

type ChartList []Chart

type ChartRowNamesList []string

type ChartRowValuesList []ChartValueList

type ChartValueList []int

type CleanOut struct {
	IsUsedDomain bool            `json:"isUsedDomain"` // use domain settings
	DeletedItems ActionAfterDays `json:"deletedItems"` // clean Deleted Items folder (maximum: 24855)
	JunkEmail    ActionAfterDays `json:"junkEmail"`    // clean Junk Email folder (maximum: 24855)
	SentItems    ActionAfterDays `json:"sentItems"`    // clean Sent Items folder (maximum: 24855)
	AutoDelete   ActionAfterDays `json:"autoDelete"`   // clean all folders (maximum: 24855)
}

type ClusterAuthentication struct {
	HostName  string `json:"hostName"`
	AdminUser string `json:"adminUser"`
	Password  string `json:"password"`
}

type ClusterConflict struct {
	Type       ClusterConflictTarget `json:"type"`
	Name       string                `json:"name"`
	Domain     string                `json:"domain"`
	HomeServer string                `json:"homeServer"`
}

type ClusterConflictList []ClusterConflict

type ClusterConflictTarget string

type ClusterDomainStatus string

type ClusterError struct {
	Type         ClusterErrorType    `json:"type"`
	ErrorMessage LocalizableMessage  `json:"errorMessage"` // is assigned if type is clError
	ConflictList ClusterConflictList `json:"conflictList"` // List of Resources/Aliases/MLists which are already defined in cluster. The conflictList is empty if type is different from dataConflict.
}

type ClusterErrorType string

type ClusterRole string

type ClusterServer struct {
	Hostname      string                 `json:"hostname"`
	IsPrimary     bool                   `json:"isPrimary"`
	IsLocal       bool                   `json:"isLocal"`
	Status        ClusterStatus          `json:"status"`
	ErrorMessages LocalizableMessageList `json:"errorMessages"` // is assigned if type is clError
	DomainStatus  ClusterDomainStatus    `json:"domainStatus"`
}

type ClusterServerList []ClusterServer

type ClusterStatus string

type CompanyContact struct {
	Id       KId    `json:"id"`
	Name     string `json:"name"` // name of company contact (caption of item in list of contacts)
	Company  string `json:"company"`
	Street   string `json:"street"`
	Locality string `json:"locality"`
	State    string `json:"state"`
	Zip      string `json:"zip"`
	Country  string `json:"country"`
	Url      string `json:"url"`
	Phone    string `json:"phone"`
	Fax      string `json:"fax"`
	DomainId KId    `json:"domainId"` // id of domain associated with company contact
}

type CompanyContactList []CompanyContact

type CompareOperator string

type ConcurrentConnections struct {
	IsSet bool `json:"isSet"` // is set maximum of concurrent connections?
	Value int  `json:"value"` // maximum of concurrent connections
}

type Config struct {
	// contains filtered or unexported fields
}

type Connection struct {
	Proto       Protocol      `json:"proto"`
	Extension   HttpExtension `json:"extension"`
	IsSecure    bool          `json:"isSecure"`
	Time        string        `json:"time"`
	From        string        `json:"from"`
	User        string        `json:"user"`
	Description string        `json:"description"`
}

type ConnectionList []Connection

type CoreDump struct {
	Size      ByteValueWithUnits `json:"size"`
	Timestamp DateTimeStamp      `json:"timestamp"`
}

type CreateResult struct {
	InputIndex int `json:"inputIndex"` // 0-based index to input array, e.g. 3 means that the relates to the 4th element of the input parameter array
	Id         KId `json:"id"`         // ID of created item.
}

type CreateResultList []CreateResult

type Credentials struct {
	UserName string `json:"userName"` // UserName
	Password string `json:"password"` // Password
}

type CustomImage struct {
	IsEnabled bool   `json:"isEnabled"` // Is used
	Url       string `json:"url"`       // [READ ONLY]
	Id        string `json:"id"`        // [WRITE ONCE] Id of uploaded image.
}

type CustomRule struct {
	Id          KId              `json:"id"` // global identifier
	Enabled     bool             `json:"enabled"`
	Kind        CustomRuleKind   `json:"kind"`
	Header      string           `json:"header"`
	Content     string           `json:"content"`
	Description string           `json:"description"`
	Type        CustomRuleType   `json:"type"`
	Action      CustomRuleAction `json:"action"`
	Score       int              `json:"score"`
	LastUsed    DistanceOrNull   `json:"lastUsed"`
}

type CustomRuleAction string

type CustomRuleKind string

type CustomRuleList []CustomRule

type CustomRuleType string

type DataSource string

type Date struct {
	Year  int `json:"year"`
	Month int `json:"month"` // 0-11
	Day   int `json:"day"`   // 1-31 max day is limited by month
}

type DateTimeStamp int

type DateTimeStampList []DateTimeStamp

type DayList []DayType

type DayType string

type DayWeekMonthPeriod string

type DeliveryRule struct {
	Id          KId        `json:"id"`          // [READ-ONLY] global identification
	IsEnabled   bool       `json:"isEnabled"`   // says whether rule is enabled
	Description string     `json:"description"` // contains rules description
	Rule        FilterRule `json:"rule"`
}

type DeliveryRuleList []DeliveryRule

type DeliveryType string

type DeployedType string

type DeviceStatus string

type Directories struct {
	StorePath   string `json:"storePath"`   // Path to the store directory
	ArchivePath string `json:"archivePath"` // Path to the archive directory
	BackupPath  string `json:"backupPath"`  // Path to the backup directory
}

type Directory struct {
	Name            string `json:"name"`
	HasSubdirectory bool   `json:"hasSubdirectory"`
}

type DirectoryAccessResult string

type DirectoryAuthentication struct {
	Username string `json:"username"`
	Password string `json:"password"`
	IsSecure bool   `json:"isSecure"` // is used LDAPS?
}

type DirectoryList []Directory

type DirectoryService struct {
	IsEnabled      bool                    `json:"isEnabled"`      // directory service is in use / isEnabled must be always assigned if used in set methods
	ServiceType    DirectoryServiceType    `json:"serviceType"`    // type of the service
	CustomMapFile  string                  `json:"customMapFile"`  // Custom Generic LDAP only: custom map filename
	Authentication DirectoryAuthentication `json:"authentication"` // authentication information
	Hostname       string                  `json:"hostname"`       // directory service hostname
	BackupHostname string                  `json:"backupHostname"` // directory service backup hostname
	DirectoryName  string                  `json:"directoryName"`  // Active Directory only: Directory name
	LdapSuffix     string                  `json:"ldapSuffix"`     // Apple Directory, Kerio Directory: LDAP Search Suffix
}

type DirectoryServiceConfiguration struct {
	ServiceType    DirectoryServiceType    `json:"serviceType"`    // type of the service
	Authentication DirectoryAuthentication `json:"authentication"` // authentication information
	DirectoryName  string                  `json:"directoryName"`  // Active Directory only: Directory name
	LdapSuffix     string                  `json:"ldapSuffix"`     // Apple Directory, Kerio Directory: LDAP Search Suffix
}

type DirectoryServiceDeleteMode string

type DirectoryServiceType string

type Distance struct {
	Days    int `json:"days"`
	Hours   int `json:"hours"`
	Minutes int `json:"minutes"`
}

type DistanceOrNull struct {
	Type     DistanceType `json:"type"`
	TimeSpan Distance     `json:"timeSpan"`
}

type DistanceType string

type DnsResolverStats struct {
	HostnameQueries       string `json:"hostnameQueries"`
	CachedHostnameQueries string `json:"cachedHostnameQueries"`
	MxQueries             string `json:"mxQueries"`
	CachedMxQueries       string `json:"cachedMxQueries"`
}

type Domain struct {
	Id                        KId              `json:"id"`                        // [READ-ONLY] global identification of domain
	Name                      string           `json:"name"`                      // [REQUIRED FOR CREATE] [WRITE-ONCE] name
	Description               string           `json:"description"`               // description
	IsPrimary                 bool             `json:"isPrimary"`                 // is this domain primary?
	UserMaxCount              int              `json:"userMaxCount"`              // maximum users per domain, 'unlimited' constant can be used
	PasswordExpirationEnabled bool             `json:"passwordExpirationEnabled"` // is password expiration enabled for this domain?
	PasswordExpirationDays    int              `json:"passwordExpirationDays"`    // password expiration interval
	PasswordHistoryCount      int              `json:"passwordHistoryCount"`      // lenght of password history
	PasswordComplexityEnabled bool             `json:"passwordComplexityEnabled"` // is password complexity enabled for this domain?
	PasswordMinimumLength     int              `json:"passwordMinimumLength"`     // minimum password length for complexity feature
	OutgoingMessageLimit      SizeLimit        `json:"outgoingMessageLimit"`      // outgoing message size limit
	DeletedItems              ActionAfterDays  `json:"deletedItems"`              // clean Deleted Items folder (AC maximum: 24855)
	JunkEmail                 ActionAfterDays  `json:"junkEmail"`                 // clean Junk Email folder (AC maximum: 24855)
	SentItems                 ActionAfterDays  `json:"sentItems"`                 // clean Sent Items folder (AC maximum: 24855)
	AutoDelete                ActionAfterDays  `json:"autoDelete"`                // clean all folders (AC minimun:30, maximum: 24855)
	KeepForRecovery           ActionAfterDays  `json:"keepForRecovery"`           // keep deleted messages for recovery
	AliasList                 StringList       `json:"aliasList"`                 // list of domain alternative names
	ForwardingOptions         Forwarding       `json:"forwardingOptions"`         // forwarding settings
	Service                   DirectoryService `json:"service"`                   // directory service configuration
	DomainFooter              Footer           `json:"domainFooter"`              // domain footer setting
	KerberosRealm             string           `json:"kerberosRealm"`             // Kerberos Realm name
	WinNtName                 string           `json:"winNtName"`                 // Windows NT domain name - available on windows only
	PamRealm                  string           `json:"pamRealm"`                  // PAM Realm name - available on linux only
	IpAddressBind             OptionalString   `json:"ipAddressBind"`             // specific IP address bind
	Logo                      WebmailLogo      `json:"logo"`                      // user defined logo
	CustomClientLogo          CustomImage      `json:"customClientLogo"`          // Use custom logo in Kerio Connect Client (if not enabled global option from AdvancedOptionsSetting.webMail is used)
	CheckSpoofedSender        bool             `json:"checkSpoofedSender"`        //
	RenameInfo                DomainRenameInfo `json:"renameInfo"`                // [READ-ONLY] if domain was renamed, contain old and new domain name
	DomainQuota               DomainQuota      `json:"domainQuota"`               // domain's quota settings
	IsDistributed             bool             `json:"isDistributed"`             // [READ-ONLY] if domain is distributed
	IsDkimEnabled             bool             `json:"isDkimEnabled"`             // true if DKIM is used for this domain
	IsLdapManagementAllowed   bool             `json:"isLdapManagementAllowed"`   // [READ-ONLY] true if directory service user/group can be created/deleted
	IsInstantMessagingEnabled bool             `json:"isInstantMessagingEnabled"` // true if Instant Messaging is enabled for this domain
	UseRemoteArchiveAddress   bool             `json:"useRemoteArchiveAddress"`   // if true emails are archived to remoteArchiveAddress
	RemoteArchiveAddress      string           `json:"remoteArchiveAddress"`      // remote archiving address
	ArchiveLocalMessages      bool             `json:"archiveLocalMessages"`      // if true emails from emails are archived to remoteArchiveAddress
	ArchiveIncomingMessages   bool             `json:"archiveIncomingMessages"`   // if true emails are archived to remoteArchiveAddress
	ArchiveOutgoingMessages   bool             `json:"archiveOutgoingMessages"`   // if true emails are archived to remoteArchiveAddress
	ArchiveBeforeFilter       bool             `json:"archiveBeforeFilter"`       // if true emails are archived before content filter check
}

type DomainList []Domain

type DomainQuota struct {
	DiskSizeLimit SizeLimit          `json:"diskSizeLimit"` // max. disk usage
	ConsumedSize  ByteValueWithUnits `json:"consumedSize"`  // [READ-ONLY] current disk usage
	Notification  QuotaNotification  `json:"notification"`  // option for notification
	WarningLimit  int                `json:"warningLimit"`  // limit in per cent
	Email         string             `json:"email"`         // if quota is exceeded the notification will be sent to this address
	Blocks        bool               `json:"blocks"`        // if reaching the quota will block creation of a new items
}

type DomainRenameInfo struct {
	IsRenamed bool   `json:"isRenamed"`
	OldName   string `json:"oldName"`
	NewName   string `json:"newName"`
}

type DomainSetting struct {
	Hostname               string `json:"hostname"`               // internet hostname - how this machine introduces itself in SMTP,POP3...
	PublicFoldersPerDomain bool   `json:"publicFoldersPerDomain"` // true=public folders are unique per each domain / false=global for all domains
	ServerId               KId    `json:"serverId"`               // id of server primary used in cluster
}

type Download struct {
	Url    string `json:"url"`    // download url
	Name   string `json:"name"`   // filename
	Length int    `json:"length"` // file size in bytes
}

type DownloadList []Download

type DumpList []CoreDump

type EffectiveUserRights struct {
	UserId               KId  `json:"userId"`               // [READ-ONLY] global identification
	HasDomainRestriction bool `json:"hasDomainRestriction"` // user can send/receive from/to his/her domain only
}

type EffectiveUserRightsList []EffectiveUserRights

type EmailAddress struct {
	Address            string           `json:"address"`
	Name               string           `json:"name"`
	Preferred          bool             `json:"preferred"`
	IsValidCertificate bool             `json:"isValidCertificate"`
	Type               EmailAddressType `json:"type"`
	RefId              KId              `json:"refId"` // Global identification of reference. Valid for types 'RefContact' and 'RefDistributionList'.
	Extension          ABExtension      `json:"extension"`
}

type EmailAddressList []EmailAddress

type EmailAddressType string

type EmailForwarding struct {
	Mode           UserForwardMode      `json:"mode"`
	EmailAddresses UserEmailAddressList `json:"emailAddresses"` // list of email addresses, make sense only for UForwardDeliver
}

type Entity string

type EntityDetail struct {
	Kind Entity `json:"kind"` // which entity is inserting
	Id   KId    `json:"id"`   // entity global identification of updated entity
}

type EntityDuplicate struct {
	Kind             Entity `json:"kind"` // which entity was found as first duplicate
	Name             string `json:"name"` // name of duplicate
	CollisionAddress string `json:"collisionAddress"`
	Win              bool   `json:"win"`       // if entity is winner in this collision of mail address
	IsPattern        bool   `json:"isPattern"` // is true if it is the pattern to check (self duplicity)
}

type EntityDuplicateList []EntityDuplicate

type Error struct {
	InputIndex        int                          `json:"inputIndex"`        // 0-based index to input array, e.g. 3 means that the relates to the 4th element of the input parameter array
	Code              int                          `json:"code"`              // -32767..-1 (JSON-RPC) or 1..32767 (application)
	Message           string                       `json:"message"`           // text with placeholders %1, %2, etc., e.g. "User %1 cannot be deleted."
	MessageParameters LocalizableMessageParameters `json:"messageParameters"` // strings to replace placeholders in message, and message plurality.
}

type ErrorList []Error

type ErrorReport struct {
	Code    int    `json:"code"`
	Message string `json:"message"`
	Data    struct {
		MessageParameters struct {
			PositionalParameters []string `json:"positionalParameters"`
			Plurality            int      `json:"plurality"`
		} `json:"messageParameters"`
	} `json:"data"`
}

type EtrnDownload struct {
	Id                    KId    `json:"id"`
	IsActive              bool   `json:"isActive"`
	Server                string `json:"server"`  // server URL
	Domains               string `json:"domains"` // semicolon separated list of domain names
	Description           string `json:"description"`
	RequireAuthentication bool   `json:"requireAuthentication"` // Is authentication required?
	UserName              string `json:"userName"`              // make sense only if authentication is required
	Password              string `json:"password"`              // make sense only if authentication is required
}

type EtrnDownloadList []EtrnDownload

type EvaluationModeType string

type ExpireInfo struct {
	Type          ExpireType `json:"type"`          // type of expiration
	IsUnlimited   bool       `json:"isUnlimited"`   // is it a special license with expiration == never ?
	RemainingDays int        `json:"remainingDays"` // days remaining to subscription expiration
	Date          int        `json:"date"`          // last date of subscription
}

type ExpireType string

type ExportFormat string

type Extension struct {
	Name string `json:"name"` // extension name
}

type ExtensionList []Extension

type FacilityUnit string

type FailureAndBounce struct {
	TransientFailures string `json:"transientFailures"` // transient delivery failures
	PermanentFailures string `json:"permanentFailures"` // permanent delivery failures
}

type FileFormatType string

type FilterAction struct {
	Type       FilterActionType `json:"type"`
	Parameters StringList       `json:"parameters"` // list of parameters (see FilterActionType for more info)
}

type FilterActionList []FilterAction

type FilterActionType string

type FilterComparatorType string

type FilterCondition struct {
	TestedTarget FilterConditionType  `json:"testedTarget"` // some aspect of message that will be tested using selected comparator and against parameters
	Comparator   FilterComparatorType `json:"comparator"`   // type of target comparator (has to be set correctly, even for CtAttachment and CtAll - CcNoComparator)
	Parameters   StringList           `json:"parameters"`   // zero, one or more values that will be used to compare to target using selected comparator
}

type FilterConditionList []FilterCondition

type FilterConditionType string

type FilterRule struct {
	IsIncomplete   bool                `json:"isIncomplete"`   // if rule is not completed (it does not contain any definition of conditions and actions)
	EvaluationMode EvaluationModeType  `json:"evaluationMode"` // determines evaluation mod of initial conditions
	Conditions     FilterConditionList `json:"conditions"`     // list of rule's initial conditions
	Actions        FilterActionList    `json:"actions"`        // list of rule's actions (performed if initial conditions are meet)
}

type FolderIcon string

type FolderInfo struct {
	FolderName     string       `json:"folderName"`
	ReferenceCount int          `json:"referenceCount"`
	IndexLoaded    bool         `json:"indexLoaded"`
	Users          UserNameList `json:"users"`
}

type FolderInfoList []FolderInfo

type Footer struct {
	IsUsed         bool   `json:"isUsed"`         // is footer used
	Text           string `json:"text"`           // text that will be appended to every message sent from this domain
	IsHtml         bool   `json:"isHtml"`         // if is value false the text is precessed as plaintext
	IsUsedInDomain bool   `json:"isUsedInDomain"` // footer is used also for e-mails within domain
}

type Forwarding struct {
	IsEnabled   bool         `json:"isEnabled"`   // is forwarding enabled?
	Host        string       `json:"host"`        // hostname or IP address to forward
	Port        int          `json:"port"`        // host port
	How         DeliveryType `json:"how"`         // how to deliver
	PreventLoop bool         `json:"preventLoop"` // do not deliver to domain alias (applicable when Domain.aliasList is not empty)
}

type ForwardingOptions struct {
	IsEnabled   bool   `json:"isEnabled"`
	Host        string `json:"host"`
	Port        int    `json:"port"`
	How         string `json:"how"`
	PreventLoop bool   `json:"preventLoop"`
}

type FoundVirusBehavior struct {
	Reaction        ReactionOnVirus `json:"reaction"`
	ForwardOriginal OptionalString  `json:"forwardOriginal"` // should be original message forwarded?
	ForwardFiltered OptionalString  `json:"forwardFiltered"` // should be filtered message forwarded?
}

type FulltextRebuildStatus struct {
	Status       FulltextStatus `json:"status"`       // [READ ONLY] state of rebuild process
	UsersLeft    int            `json:"usersLeft"`    // [status IndexRebuilding] - the current number of user re-indexed mailboxes
	MessagesLeft int            `json:"messagesLeft"` // [status IndexMessages] - number of new delivered messages to index
	Size         int            `json:"size"`         // index size or estimate size in status IndexMessages or IndexRebuilding
	FreeSpace    int            `json:"freeSpace"`    // free space in path for index files
}

type FulltextRebuildingCommand struct {
	Scope FulltextScope `json:"scope"`
	Id    KId           `json:"id"` // domain id for scope 'IndexDomain' or user id for scope 'IndexUser'
}

type FulltextScope string

type FulltextSetting struct {
	Enabled bool   `json:"enabled"` // enabled/disabled
	Path    string `json:"path"`    // path to directory where are indexes
}

type FulltextStatus string

type Greylisting struct {
	Enabled bool `json:"enabled"` // is greylisting enabled?
	/// When enabled is set to true, the setAntiSpamSetting method attempts to connect to the greylisting service asynchronously.
	/// When enabled is set to false, connection to the greylisting service is closed.
	CustomWhiteList  OptionalEntity    `json:"customWhiteList"`  // switchable custom whitelist IP group
	Status           GreylistingStatus `json:"status"`           // read only: current status
	MessagesAccepted string            `json:"messagesAccepted"` // read only: messages accepted
	MessagesDelayed  string            `json:"messagesDelayed"`  // read only: messages temoprarily rejected
	MessagesSkipped  string            `json:"messagesSkipped"`  // read only: messages skipped
}

type GreylistingStats struct {
	MessagesAccepted string `json:"messagesAccepted"`
	MessagesDelayed  string `json:"messagesDelayed"`
	MessagesSkipped  string `json:"messagesSkipped"`
}

type GreylistingStatus string

type Group struct {
	Id                   KId          `json:"id"`                   // global identification of group
	DomainId             KId          `json:"domainId"`             // identification in which domain group exists
	Name                 string       `json:"name"`                 // group name
	EmailAddresses       StringList   `json:"emailAddresses"`       // group email addresses
	Role                 UserRoleType `json:"role"`                 // access rights list
	HasDomainRestriction bool         `json:"hasDomainRestriction"` // user can send/receive from/to his domain only
	Description          string       `json:"description"`          // description
	ItemSource           DataSource   `json:"itemSource"`           // internal database or mapped from LDAP?
	PublishInGal         bool         `json:"publishInGal"`         // publish user in global address list? - default is true
}

type GroupLimit struct {
	IsUsed  bool           `json:"isUsed"`  // is group limit set
	IpGroup IpAddressGroup `json:"ipGroup"` // IP address group
}

type GroupList []Group

type GroupRemovalRequest struct {
	GroupId KId                        `json:"groupId"` // ID of group to be removed
	Mode    DirectoryServiceDeleteMode `json:"mode"`    // delete mode
}

type GroupRemovalRequestList []GroupRemovalRequest

type HighlightColor string

type HighlightItem struct {
	Id             KId            `json:"id"`             // global identification
	Enabled        bool           `json:"enabled"`        // Rule is [dis|en]abled
	Description    string         `json:"description"`    // Text description
	Condition      string         `json:"condition"`      // Match condition
	IsRegex        bool           `json:"isRegex"`        // Is condition held as regular expression? (server does NOT check if regex is valid)
	Color          HighlightColor `json:"color"`          // Highlight matching log lines by this color
	IsOrderChanged bool           `json:"isOrderChanged"` // True if item order was changed by user
}

type HighlightRules []HighlightItem

type HistogramIntervalType string

type HistogramType string

type HomeServer struct {
	Id   KId    `json:"id"`   // server's id
	Name string `json:"name"` // server's Internet hostname
}

type HomeServerList []HomeServer

type HourOrDay string

type HttpExtension string

type HttpProxyOptions struct {
	IsEnabled              bool   `json:"isEnabled"` // Use HTTP proxy for antivirus updates, Kerio update checker and other web services
	Address                string `json:"address"`
	Port                   int    `json:"port"`
	RequiresAuthentication bool   `json:"requiresAuthentication"` // Proxy requires authentication
	UserName               string `json:"userName"`
	Password               string `json:"password"`
}

type IdEntity struct {
	Id   KId    `json:"id"`   // global identifier of entity
	Name string `json:"name"` // [READ-ONLY] name or description of entity
}

type ImapServerStats struct {
	TotalIncomingConnections string `json:"totalIncomingConnections"`
	AuthenticationFailures   string `json:"authenticationFailures"`
}

type ImportServer struct {
	DirectoryType      ServerDirectoryType `json:"directoryType"`
	RemoteDomainName   string              `json:"remoteDomainName"`
	Address            string              `json:"address"` // server IP or FQDN
	LoginName          string              `json:"loginName"`
	Password           string              `json:"password"`
	LdapFilter         string              `json:"ldapFilter"`
	IsSecureConnection bool                `json:"isSecureConnection"`
}

type Importee struct {
	UserItem     User   `json:"userItem"`     // user data
	IsImportable bool   `json:"isImportable"` // [READ-ONLY] user can be imported
	Message      string `json:"message"`      // [READ-ONLY] error message if user is not importable
}

type ImporteeList []Importee

type IntegerList []int

type IntegratedAntiSpamEngine struct {
	Enabled       bool                     `json:"enabled"`
	Score         int                      `json:"score"`         // Spam score(default 10)
	NegativeScore int                      `json:"negativeScore"` // Score for legit messages (default 0)
	SubmitSpam    bool                     `json:"submitSpam"`    // Submit spam samples(default on)
	SubmitLegit   bool                     `json:"submitLegit"`   // Submit legit samples(default on)
	Status        IntegratedAntiSpamStatus `json:"status"`        // [READ-ONLY]
	IsLicensed    bool                     `json:"isLicensed"`    // [READ-ONLY] Is license valid and not expired? If false engine is not running no matter on value in enabled.
}

type IntegratedAntiSpamStatus string

type IntegratedAvirUpdateStatus struct {
	Status  UpdateStatus `json:"status"`  // state of update process
	Percent int          `json:"percent"` // percent of downloaded data
}

type IntegratedEngine struct {
	CheckForUpdates         bool           `json:"checkForUpdates"`   // should we periodically ask for a new version?
	UpdatePeriod            int            `json:"updatePeriod"`      // update checking period in hours
	DatabaseAge             DistanceOrNull `json:"databaseAge"`       // how old is virus database
	LastUpdateCheck         DistanceOrNull `json:"lastUpdateCheck"`   // how long is since last database update check
	DatabaseVersion         string         `json:"databaseVersion"`   // virus database version
	EngineVersion           string         `json:"engineVersion"`     // scanning engine version
	IsPluginAvailable       bool           `json:"isPluginAvailable"` // says if plugins dll is on hardrive
	IsLiveProtectionEnabled bool           `json:"isLiveProtectionEnabled"`
}

type InternetConnection string

type InternetSettings struct {
	Type                 InternetConnection `json:"type"`                 // type of Internet settings connection
	RasLine              string             `json:"rasLine"`              // name of RAS line
	UseSystemCredentials bool               `json:"useSystemCredentials"` // use username and password defined in system
	RasUser              string             `json:"rasUser"`              // RAS username
	RasPassword          string             `json:"rasPassword"`          // write only; password to RAS
	DialOnHigh           bool               `json:"dialOnHigh"`           // enable dial-up on high priority message
}

type IpAddress string

type IpAddressEntry struct {
	Id             KId                `json:"id"`
	GroupId        KId                `json:"groupId"`
	SharedId       KId                `json:"sharedId"` // read-only; filled when the item is shared in MyKerio
	GroupName      string             `json:"groupName"`
	Description    string             `json:"description"`
	Type           IpAddressGroupType `json:"type"`
	Enabled        bool               `json:"enabled"`
	Status         StoreStatus        `json:"status"`
	Host           string             `json:"host"`  // name, IP or IP prefix
	Addr1          IpAddress          `json:"addr1"` // network/from, e.g. 192.168.0.0
	Addr2          IpAddress          `json:"addr2"` // mask/to, e.g. 255.255.0.0
	ChildGroupId   KId                `json:"childGroupId"`
	ChildGroupName string             `json:"childGroupName"`
}

type IpAddressEntryList []IpAddressEntry

type IpAddressGroup struct {
	Id   KId    `json:"id"`
	Name string `json:"name"`
}

type IpAddressGroupList []IpAddressGroup

type IpAddressGroupType string

type IpAddressList []IpAddress

type IpLimit struct {
	MaximumFromIp      ItemCountLimit `json:"maximumFromIp"`      // maximum number of messages per hour from 1 IP address
	MaximumConnections ItemCountLimit `json:"maximumConnections"` // maximum number of concurrent SMTP connections from 1 IP address
	MaximumUnknowns    ItemCountLimit `json:"maximumUnknowns"`    // maximum number of unknown recipients
	IpAddressGroupName string         `json:"ipAddressGroupName"` // output only: name of IP group on which limits are NOT applied
	IpAddressGroupId   KId            `json:"ipAddressGroupId"`   // ID of IP group on which limits are NOT applied
}

type ItemCountLimit struct {
	IsActive bool `json:"isActive"`
	Limit    int  `json:"limit"`
}

type ItemName string

type JavaScriptDate string

type KId string

type KIdList []KId

type KeepForRecovery struct {
	IsEnabled bool `json:"isEnabled"`
	Days      int  `json:"days"`
}

type KoffOptions struct {
	UpgradePolicy KoffUpgradePolicy `json:"upgradePolicy"`
}

type KoffUpgradePolicy string

type LangDescription struct {
	Name      string `json:"name"`      // name of language (national form)
	Code      string `json:"code"`      // code of language; E.g.: "en-gb"
	ShortCode string `json:"shortCode"` // short code of language which is used to identify language file; e.g. "en"
}

type LangDescriptionList []LangDescription

type LastBackupStatus string

type LastLogin struct {
	DateTime DateTimeStamp `json:"dateTime"` // date and time of last login
	Protocol string        `json:"protocol"` // protocol name of last login, example POP3
}

type LdapServerStats struct {
	TotalIncomingConnections string `json:"totalIncomingConnections"`
	AuthenticationFailures   string `json:"authenticationFailures"`
	TotalSearchRequests      string `json:"totalSearchRequests"`
}

type LeaveOnServer struct {
	Enabled           bool         `json:"enabled"`
	RemoveAfterPeriod OptionalLong `json:"removeAfterPeriod"`
}

type LicenseDetail struct {
	Organization string `json:"organization"` // compulsory
	Person       string `json:"person"`       // compulsory
	Email        string `json:"email"`        // compulsory
	Phone        string `json:"phone"`        // compulsory
	Web          string `json:"web"`
	Country      string `json:"country"` // compulsory
	State        string `json:"state"`   // compulsory for countries such as USA, Canada, Australia etc.
	City         string `json:"city"`    // compulsory
	Street       string `json:"street"`  // compulsory
	Zip          string `json:"zip"`     // compulsory
	Comment      string `json:"comment"`
}

type LicenseExpireInfo []ExpireInfo

type Listener struct {
	Type    AddressType `json:"type"`
	Address IpAddress   `json:"address"` // can obtain localizable string "All addresses"
	Port    int         `json:"port"`
}

type ListenerList []Listener

type LocalizableMessage struct {
	Message              string     `json:"message"`              // text with placeholders %1, %2, etc., e.g. "User %1 cannot be deleted."
	PositionalParameters StringList `json:"positionalParameters"` // additional strings to replace the placeholders in message (first string replaces %1 etc.)
	Plurality            int        `json:"plurality"`            // count of items, used to distinguish among singular/paucal/plural; 1 for messages with no counted items
}

type LocalizableMessageList []LocalizableMessage

type LocalizableMessageParameters struct {
	PositionalParameters StringList `json:"positionalParameters"` // additional strings to replace the placeholders in message (first string replaces %1 etc.)
	Plurality            int        `json:"plurality"`            // count of items, used to distinguish among singular/paucal/plural; 1 for messages with no counted items
}

type LogFileSettings struct {
	Enabled  bool   `json:"enabled"`  // Is logging to file enabled
	FileName string `json:"fileName"` // log file name
}

type LogItem struct {
	LogName     LogType `json:"logName"`     // name of the log
	HasMessages bool    `json:"hasMessages"` // has the log messages?
}

type LogRotationSettings struct {
	Period      RotationPeriod `json:"period"`      // How often does log rotate?
	MaxLogSize  int            `json:"maxLogSize"`  // Maximum log file size [MegaBytes]; Unlimited CAN be used
	RotateCount int            `json:"rotateCount"` // How many rotated files can be kept at most?; Unlimited CANNOT be used
}

type LogRow struct {
	Content   string         `json:"content"`   // 1 data row
	Highlight HighlightColor `json:"highlight"` // appropriate highlight color
}

type LogRowList []LogRow

type LogSet []LogItem

type LogSettings struct {
	General  LogFileSettings     `json:"general"`  // general log settings
	Rotation LogRotationSettings `json:"rotation"` // log rotation settings
	Syslog   SyslogSettings      `json:"syslog"`   // syslog settings
}

type LogType string

type LogicalOperator string

type LoginStats struct {
	Count     int    `json:"count"`
	LastLogin string `json:"lastLogin"`
}

type MLMemberImportee struct {
	Member       UserOrEmail `json:"member"`       // ML member data
	IsImportable bool        `json:"isImportable"` // ML member can be imported
	Message      string      `json:"message"`      // error message if ML member is not importable
}

type MLMemberImporteeList []MLMemberImportee

type MailboxCount struct {
	Active int `json:"active"` // the number of active mailboxes on server
	Total  int `json:"total"`  // the number of created users on server
}

type ManipulationError struct {
	Id           KId                `json:"id"` // entity KId, can be user, group, alias, ML...
	ErrorMessage LocalizableMessage `json:"errorMessage"`
}

type ManipulationErrorList []ManipulationError

type MasterAuthenticationOptions struct {
	IsEnabled        bool   `json:"isEnabled"`        // Enable master authentication to this server
	GroupRestriction KId    `json:"groupRestriction"` // Allow master authentication only from IP address group
	Password         string `json:"password"`         // [WriteOnly] Master password
}

type MaximumUsers struct {
	IsUnlimited  bool          `json:"isUnlimited"`  // is it a special case with no limit for users ?
	AllowedUsers int           `json:"allowedUsers"` // number of allowed users (take minimum of server and domain limit)
	Limit        int           `json:"limit"`        // max. user limit
	LimitType    UserLimitType `json:"limitType"`    // max. user limit type, if domain limit == license limit -> use license
}

type MessageInProcess struct {
	Id          KId                `json:"id"`          // Queue ID
	MessageSize ByteValueWithUnits `json:"messageSize"` // message size in appropriate units
	From        string             `json:"from"`        // sender email address
	To          string             `json:"to"`          // recipient email address
	Status      MessageStatus      `json:"status"`      // message status
	Percentage  int                `json:"percentage"`  // only for processing: completed percentage
	Server      string             `json:"server"`      // server name or IP
	Time        string             `json:"time"`        // time in process
}

type MessageInProcessList []MessageInProcess

type MessageInQueue struct {
	Id           KId                `json:"id"`           // Queue ID
	CreationTime string             `json:"creationTime"` // when the message was created
	NextTry      string             `json:"nextTry"`      // when to try send message
	MessageSize  ByteValueWithUnits `json:"messageSize"`  // message size in appropriate units
	From         string             `json:"from"`         // sender email address
	To           string             `json:"to"`           // recipient email address
	Status       string             `json:"status"`       // message status
	AuthSender   string             `json:"authSender"`   // email address of authenticated sender
	SenderIp     IpAddress          `json:"senderIp"`     // IP address of authenticated sender
}

type MessageInQueueList []MessageInQueue

type MessageStatus string

type MessageThroughput struct {
	Count      string             `json:"count"`      // how many messages
	Volume     ByteValueWithUnits `json:"volume"`     // how much space is occupied by messages
	Recipients string             `json:"recipients"` // how many recipients in messages
}

type MigrationStatus struct {
	MigrationStatus    MigrationStatusEnum `json:"migrationStatus"`    // current status of the migration
	ProgressInPercents int                 `json:"progressInPercents"` // number from 0 to 100
	ErrorMessage       string              `json:"errorMessage"`       // If migrationStatus is migError, errorMessage optionaly contains detailed info about error in english
}

type MigrationStatusEnum string

type MigrationTask struct {
	Id           KId        `json:"id"`           // id of migration task
	UserId       KId        `json:"userId"`       // id of migrated user
	UserName     string     `json:"userName"`     // name of migrated user
	SourceServer HomeServer `json:"sourceServer"` // source homeserver
	// HomeServer targetServer;   // in current implementation it's always current server -
	Status MigrationStatus `json:"status"` // status of the migration
}

type MigrationTaskList []MigrationTask

type MiscellaneousOptions struct {
	LogHostNames              bool `json:"logHostNames"`              // Log hostnames for incoming connections
	ShowProgramNameAndVersion bool `json:"showProgramNameAndVersion"` // Show program name and version in network communication for non-authenticated users
	InsertXEnvelopeTo         bool `json:"insertXEnvelopeTo"`         // Insert X-Envelope-To header to locally delivered messages
	EnableTNEFDecoding        bool `json:"enableTNEFDecoding"`        // Enable decoding of TNEF messages (winmail.dat attachments)
	EnableUUEncodedConversion bool `json:"enableUUEncodedConversion"` // Enable conversion of uuencoded messages to MIME
}

type Ml struct {
	Id                KId                `json:"id"`                // [READ-ONLY] global identification of ML
	DomainId          KId                `json:"domainId"`          // [REQUIRED FOR CREATE] [WRITE-ONCE] identification in which domain ML exists
	Name              string             `json:"name"`              // [REQUIRED FOR CREATE] [WRITE-ONCE] ML name, name@domain is email address
	Description       string             `json:"description"`       // description
	LanguageId        KId                `json:"languageId"`        // language to be spoken withing mailing list
	WelcomeString     string             `json:"welcomeString"`     // string to be sent as welcome of a new memeber
	FooterString      string             `json:"footerString"`      // string to be sent as footer of each contribution
	Subscription      SubscriptionPolicy `json:"subscription"`      // type of ML subscription policy
	Posting           PostingPolicy      `json:"posting"`           // type of ML posting policy
	ReplyTo           MlReplyTo          `json:"replyTo"`           // how should be replied to
	OtherAddress      string             `json:"otherAddress"`      // if replyTo is OtherAddress, it contains email address
	SubjectPrefix     string             `json:"subjectPrefix"`     // prefix for each subject
	HideSenderAddress bool               `json:"hideSenderAddress"` // replace sender's email address by ML address
	AllowEmptySubject bool               `json:"allowEmptySubject"` // allow posting with empty subject
	Archive           ArchiveSettings    `json:"archive"`           // archive settings
	MembersCount      int                `json:"membersCount"`      // [READ-ONLY] Number of members.
	HomeServer        HomeServer         `json:"homeServer"`        // [READ-ONLY] Id of users homeserver if server is in Cluster
}

type MlList []Ml

type MlMembership string

type MlPermission string

type MlReplyTo string

type MobileDevice struct {
	ProtocolType        ProtocolType   `json:"protocolType"`
	DeviceId            string         `json:"deviceId"`
	ProtocolVersion     string         `json:"protocolVersion"`     // used ActiveSync protocol version
	RegistrationDate    DateTimeStamp  `json:"registrationDate"`    // date of registration
	RegistrationDateIso UtcDateTime    `json:"registrationDateIso"` // date of registration
	LastSyncDate        DateTimeStamp  `json:"lastSyncDate"`        // date of last synchronization
	LastSyncDateIso     UtcDateTime    `json:"lastSyncDateIso"`     // date of last synchronization
	FolderList          SyncFolderList `json:"folderList"`          // list of synchronized folders
	Status              DeviceStatus   `json:"status"`              // wipe status
	Method              SyncMethod     `json:"method"`              // synchronization method
	RemoteHost          string         `json:"remoteHost"`          // typically IP address of device
	Os                  string         `json:"os"`                  // operating system - eg. Windows Mobile(R) 2003
	Platform            string         `json:"platform"`            // PocketPC
	DeviceIcon          string         `json:"deviceIcon"`          // Device icon Eg. 'pocketpc' or 'unknown'
}

type MobileDeviceList []MobileDevice

type ModeratorPermission string

type NamedConstant struct {
	Name  string `json:"name"`  // constant name
	Value string `json:"value"` // a value of constant
}

type NamedConstantList []NamedConstant

type NamedMultiValue struct {
	Name  string     `json:"name"` // Name-value pair
	Value StringList `json:"value"`
}

type NamedMultiValueList []NamedMultiValue

type NamedValue struct {
	Name  string `json:"name"` // Name-value pair
	Value string `json:"value"`
}

type NamedValueList []NamedValue

type NotificationType string

type Notifications struct {
	Success string `json:"success"` // how many sent success notifications
	Delay   string `json:"delay"`   // how many sent delay notifications
	Failure string `json:"failure"` // how many sent failure notifications
}

type OccupiedStorage struct {
	Total      ByteValueWithUnits `json:"total"`      // total space on disc
	Occupied   ByteValueWithUnits `json:"occupied"`   // occupied space on disc
	Percentage string             `json:"percentage"` // how many per cent is occupied
}

type OperatorOptions struct {
	IsEnabled bool   `json:"isEnabled"`
	Address   string `json:"address"`
}

type OptionalEntity struct {
	Enabled bool   `json:"enabled"`
	Id      KId    `json:"id"` // global identifier
	Name    string `json:"name"`
}

type OptionalLong struct {
	Enabled bool `json:"enabled"`
	Value   int  `json:"value"`
}

type OptionalString struct {
	Enabled bool   `json:"enabled"`
	Value   string `json:"value"`
}

type OtherStats struct {
	Largest ByteValueWithUnits `json:"largest"` // the largest messages received by server
	Loops   string             `json:"loops"`   // how many detected message loops
}

type OutgoingMessageLimit struct {
	IsActive bool `json:"isActive"`
	Limit    struct {
		Value int    `json:"value"`
		Units string `json:"units"`
	} `json:"limit"`
}

type PercentHistogram []float64

type PersonalContact struct {
	CommonName           string           `json:"commonName"`
	FirstName            string           `json:"firstName"`
	MiddleName           string           `json:"middleName"`
	SurName              string           `json:"surName"`
	TitleBefore          string           `json:"titleBefore"`
	TitleAfter           string           `json:"titleAfter"`
	NickName             string           `json:"nickName"`
	PhoneNumberWorkVoice string           `json:"phoneNumberWorkVoice"`
	PhoneNumberMobile    string           `json:"phoneNumberMobile"`
	PostalAddressWork    PostalAddress    `json:"postalAddressWork"`
	UrlWork              string           `json:"urlWork"`
	BirthDay             UtcDateTime      `json:"birthDay"`
	Anniversary          UtcDateTime      `json:"anniversary"`
	CompanyName          string           `json:"companyName"`
	DepartmentName       string           `json:"departmentName"`
	Profession           string           `json:"profession"`
	ManagerName          string           `json:"managerName"`
	AssistantName        string           `json:"assistantName"`
	Comment              string           `json:"comment"`
	IMAddress            string           `json:"IMAddress"`
	Photo                PhotoAttachment  `json:"photo"`
	IsReadOnly           bool             `json:"isReadOnly"`
	EmailAddresses       EmailAddressList `json:"emailAddresses"`
}

type PersonalContactList []PersonalContact

type PhoneNumber struct {
	Type      PhoneNumberType `json:"type"`
	Number    string          `json:"number"` // A number - based on the X.500 Telephone Number attribute
	Extension ABExtension     `json:"extension"`
}

type PhoneNumberList []PhoneNumber

type PhoneNumberType string

type PhotoAttachment struct {
	Id  string `json:"id"`  // origin ID of attachment or ID from upload response
	Url string `json:"url"` // [READ-ONLY] Relative URL from root of web. Eg.: /webmail/api/download/attachment/ba5767a9-7a70-4c90-a6bf-dc8dd62e259c/14/0-1-0-1/picture.jpg
}

type Pop3Account struct {
	Id              KId                `json:"id"`
	IsActive        bool               `json:"isActive"`
	Server          string             `json:"server"`   // POP3 server name
	UserName        string             `json:"userName"` // username on POP3 server
	Password        string             `json:"password"` // password appropriate to username
	Description     string             `json:"description"`
	DeliveryAddress string             `json:"deliveryAddress"`
	UseSortingRules bool               `json:"useSortingRules;//"` // If value is true sortType will save otherwise deliveryAddress will save. Default is false.
	SortType        string             `json:"sortType"`
	DropDuplicates  bool               `json:"dropDuplicates"` // drop duplicate messages?
	Mode            SslMode            `json:"mode"`
	Port            int                `json:"port"`
	Authentication  Pop3Authentication `json:"authentication"`
	MessageLimit    ByteValueWithUnits `json:"messageLimit"` // per session download limit - total message size
	MaxCount        int                `json:"maxCount"`     // per session download limit - maximum message count
	LeaveOnServer   LeaveOnServer      `json:"leaveOnServer"`
}

type Pop3AccountList []Pop3Account

type Pop3Authentication string

type Pop3ClientStats struct {
	ConnectionAttempts     string `json:"connectionAttempts"`
	ConnectionFailures     string `json:"connectionFailures"`
	AuthenticationFailures string `json:"authenticationFailures"`
	TotalDownloads         string `json:"totalDownloads"`
}

type Pop3ServerStats struct {
	TotalIncomingConnections string `json:"totalIncomingConnections"`
	AuthenticationFailures   string `json:"authenticationFailures"`
	SentMessages             string `json:"sentMessages"`
}

type Pop3Sorting struct {
	Id          KId    `json:"id"`
	IsActive    bool   `json:"isActive"`
	SortAddress string `json:"sortAddress"`
	DeliverTo   string `json:"deliverTo"`
	Description string `json:"description"`
}