enums.generated.go

// Copyright 2021 Converter Systems LLC. All rights reserved.

// Code generated by go generate; DO NOT EDIT.

package ua

// NodeIDType enumeration.
type NodeIDType int32

// NodeIDType enumeration.
const (
    NodeIDTypeTwoByte       NodeIDType = 0
    NodeIDTypeFourByte      NodeIDType = 1
    NodeIDTypeNumeric       NodeIDType = 2
    NodeIDTypeString        NodeIDType = 3
    NodeIDTypeGUID          NodeIDType = 4
    NodeIDTypeByteString    NodeIDType = 5
)

// String returns enumeration value as string.
func (v NodeIDType) String() string {
    switch v {
    case 0: 
        return "TwoByte"
    case 1: 
        return "FourByte"
    case 2: 
        return "Numeric"
    case 3: 
        return "String"
    case 4: 
        return "GUID"
    case 5: 
        return "ByteString"
    default:
        return ""
    }
}

// NamingRuleType enumeration.
type NamingRuleType int32

// NamingRuleType enumeration.
const (
    NamingRuleTypeMandatory     NamingRuleType = 1
    NamingRuleTypeOptional      NamingRuleType = 2
    NamingRuleTypeConstraint    NamingRuleType = 3
)

// String returns enumeration value as string.
func (v NamingRuleType) String() string {
    switch v {
    case 1: 
        return "Mandatory"
    case 2: 
        return "Optional"
    case 3: 
        return "Constraint"
    default:
        return ""
    }
}

// OpenFileMode enumeration.
type OpenFileMode int32

// OpenFileMode enumeration.
const (
    OpenFileModeRead             OpenFileMode = 1
    OpenFileModeWrite            OpenFileMode = 2
    OpenFileModeEraseExisting    OpenFileMode = 4
    OpenFileModeAppend           OpenFileMode = 8
)

// String returns enumeration value as string.
func (v OpenFileMode) String() string {
    switch v {
    case 1: 
        return "Read"
    case 2: 
        return "Write"
    case 4: 
        return "EraseExisting"
    case 8: 
        return "Append"
    default:
        return ""
    }
}

// IdentityCriteriaType enumeration.
type IdentityCriteriaType int32

// IdentityCriteriaType enumeration.
const (
    IdentityCriteriaTypeUserName             IdentityCriteriaType = 1
    IdentityCriteriaTypeThumbprint           IdentityCriteriaType = 2
    IdentityCriteriaTypeRole                 IdentityCriteriaType = 3
    IdentityCriteriaTypeGroupID              IdentityCriteriaType = 4
    IdentityCriteriaTypeAnonymous            IdentityCriteriaType = 5
    IdentityCriteriaTypeAuthenticatedUser    IdentityCriteriaType = 6
)

// String returns enumeration value as string.
func (v IdentityCriteriaType) String() string {
    switch v {
    case 1: 
        return "UserName"
    case 2: 
        return "Thumbprint"
    case 3: 
        return "Role"
    case 4: 
        return "GroupID"
    case 5: 
        return "Anonymous"
    case 6: 
        return "AuthenticatedUser"
    default:
        return ""
    }
}

// TrustListMasks enumeration.
type TrustListMasks int32

// TrustListMasks enumeration.
const (
    TrustListMasksNone                   TrustListMasks = 0
    TrustListMasksTrustedCertificates    TrustListMasks = 1
    TrustListMasksTrustedCrls            TrustListMasks = 2
    TrustListMasksIssuerCertificates     TrustListMasks = 4
    TrustListMasksIssuerCrls             TrustListMasks = 8
    TrustListMasksAll                    TrustListMasks = 15
)

// String returns enumeration value as string.
func (v TrustListMasks) String() string {
    switch v {
    case 0: 
        return "None"
    case 1: 
        return "TrustedCertificates"
    case 2: 
        return "TrustedCrls"
    case 4: 
        return "IssuerCertificates"
    case 8: 
        return "IssuerCrls"
    case 15: 
        return "All"
    default:
        return ""
    }
}

// PubSubState enumeration.
type PubSubState int32

// PubSubState enumeration.
const (
    PubSubStateDisabled       PubSubState = 0
    PubSubStatePaused         PubSubState = 1
    PubSubStateOperational    PubSubState = 2
    PubSubStateError          PubSubState = 3
)

// String returns enumeration value as string.
func (v PubSubState) String() string {
    switch v {
    case 0: 
        return "Disabled"
    case 1: 
        return "Paused"
    case 2: 
        return "Operational"
    case 3: 
        return "Error"
    default:
        return ""
    }
}

// DataSetFieldFlags enumeration.
type DataSetFieldFlags int32

// DataSetFieldFlags enumeration.
const (
    DataSetFieldFlagsNone             DataSetFieldFlags = 0
    DataSetFieldFlagsPromotedField    DataSetFieldFlags = 1
)

// String returns enumeration value as string.
func (v DataSetFieldFlags) String() string {
    switch v {
    case 0: 
        return "None"
    case 1: 
        return "PromotedField"
    default:
        return ""
    }
}

// DataSetFieldContentMask enumeration.
type DataSetFieldContentMask int32

// DataSetFieldContentMask enumeration.
const (
    DataSetFieldContentMaskNone                 DataSetFieldContentMask = 0
    DataSetFieldContentMaskStatusCode           DataSetFieldContentMask = 1
    DataSetFieldContentMaskSourceTimestamp      DataSetFieldContentMask = 2
    DataSetFieldContentMaskServerTimestamp      DataSetFieldContentMask = 4
    DataSetFieldContentMaskSourcePicoSeconds    DataSetFieldContentMask = 8
    DataSetFieldContentMaskServerPicoSeconds    DataSetFieldContentMask = 16
    DataSetFieldContentMaskRawData              DataSetFieldContentMask = 32
)

// String returns enumeration value as string.
func (v DataSetFieldContentMask) String() string {
    switch v {
    case 0: 
        return "None"
    case 1: 
        return "StatusCode"
    case 2: 
        return "SourceTimestamp"
    case 4: 
        return "ServerTimestamp"
    case 8: 
        return "SourcePicoSeconds"
    case 16: 
        return "ServerPicoSeconds"
    case 32: 
        return "RawData"
    default:
        return ""
    }
}

// OverrideValueHandling enumeration.
type OverrideValueHandling int32

// OverrideValueHandling enumeration.
const (
    OverrideValueHandlingDisabled           OverrideValueHandling = 0
    OverrideValueHandlingLastUsableValue    OverrideValueHandling = 1
    OverrideValueHandlingOverrideValue      OverrideValueHandling = 2
)

// String returns enumeration value as string.
func (v OverrideValueHandling) String() string {
    switch v {
    case 0: 
        return "Disabled"
    case 1: 
        return "LastUsableValue"
    case 2: 
        return "OverrideValue"
    default:
        return ""
    }
}

// DataSetOrderingType enumeration.
type DataSetOrderingType int32

// DataSetOrderingType enumeration.
const (
    DataSetOrderingTypeUndefined                  DataSetOrderingType = 0
    DataSetOrderingTypeAscendingWriterID          DataSetOrderingType = 1
    DataSetOrderingTypeAscendingWriterIDSingle    DataSetOrderingType = 2
)

// String returns enumeration value as string.
func (v DataSetOrderingType) String() string {
    switch v {
    case 0: 
        return "Undefined"
    case 1: 
        return "AscendingWriterID"
    case 2: 
        return "AscendingWriterIDSingle"
    default:
        return ""
    }
}

// UADPNetworkMessageContentMask enumeration.
type UADPNetworkMessageContentMask int32

// UADPNetworkMessageContentMask enumeration.
const (
    UADPNetworkMessageContentMaskNone                    UADPNetworkMessageContentMask = 0
    UADPNetworkMessageContentMaskPublisherID             UADPNetworkMessageContentMask = 1
    UADPNetworkMessageContentMaskGroupHeader             UADPNetworkMessageContentMask = 2
    UADPNetworkMessageContentMaskWriterGroupID           UADPNetworkMessageContentMask = 4
    UADPNetworkMessageContentMaskGroupVersion            UADPNetworkMessageContentMask = 8
    UADPNetworkMessageContentMaskNetworkMessageNumber    UADPNetworkMessageContentMask = 16
    UADPNetworkMessageContentMaskSequenceNumber          UADPNetworkMessageContentMask = 32
    UADPNetworkMessageContentMaskPayloadHeader           UADPNetworkMessageContentMask = 64
    UADPNetworkMessageContentMaskTimestamp               UADPNetworkMessageContentMask = 128
    UADPNetworkMessageContentMaskPicoSeconds             UADPNetworkMessageContentMask = 256
    UADPNetworkMessageContentMaskDataSetClassID          UADPNetworkMessageContentMask = 512
    UADPNetworkMessageContentMaskPromotedFields          UADPNetworkMessageContentMask = 1024
)

// String returns enumeration value as string.
func (v UADPNetworkMessageContentMask) String() string {
    switch v {
    case 0: 
        return "None"
    case 1: 
        return "PublisherID"
    case 2: 
        return "GroupHeader"
    case 4: 
        return "WriterGroupID"
    case 8: 
        return "GroupVersion"
    case 16: 
        return "NetworkMessageNumber"
    case 32: 
        return "SequenceNumber"
    case 64: 
        return "PayloadHeader"
    case 128: 
        return "Timestamp"
    case 256: 
        return "PicoSeconds"
    case 512: 
        return "DataSetClassID"
    case 1024: 
        return "PromotedFields"
    default:
        return ""
    }
}

// UADPDataSetMessageContentMask enumeration.
type UADPDataSetMessageContentMask int32

// UADPDataSetMessageContentMask enumeration.
const (
    UADPDataSetMessageContentMaskNone              UADPDataSetMessageContentMask = 0
    UADPDataSetMessageContentMaskTimestamp         UADPDataSetMessageContentMask = 1
    UADPDataSetMessageContentMaskPicoSeconds       UADPDataSetMessageContentMask = 2
    UADPDataSetMessageContentMaskStatus            UADPDataSetMessageContentMask = 4
    UADPDataSetMessageContentMaskMajorVersion      UADPDataSetMessageContentMask = 8
    UADPDataSetMessageContentMaskMinorVersion      UADPDataSetMessageContentMask = 16
    UADPDataSetMessageContentMaskSequenceNumber    UADPDataSetMessageContentMask = 32
)

// String returns enumeration value as string.
func (v UADPDataSetMessageContentMask) String() string {
    switch v {
    case 0: 
        return "None"
    case 1: 
        return "Timestamp"
    case 2: 
        return "PicoSeconds"
    case 4: 
        return "Status"
    case 8: 
        return "MajorVersion"
    case 16: 
        return "MinorVersion"
    case 32: 
        return "SequenceNumber"
    default:
        return ""
    }
}

// JSONNetworkMessageContentMask enumeration.
type JSONNetworkMessageContentMask int32

// JSONNetworkMessageContentMask enumeration.
const (
    JSONNetworkMessageContentMaskNone                    JSONNetworkMessageContentMask = 0
    JSONNetworkMessageContentMaskNetworkMessageHeader    JSONNetworkMessageContentMask = 1
    JSONNetworkMessageContentMaskDataSetMessageHeader    JSONNetworkMessageContentMask = 2
    JSONNetworkMessageContentMaskSingleDataSetMessage    JSONNetworkMessageContentMask = 4
    JSONNetworkMessageContentMaskPublisherID             JSONNetworkMessageContentMask = 8
    JSONNetworkMessageContentMaskDataSetClassID          JSONNetworkMessageContentMask = 16
    JSONNetworkMessageContentMaskReplyTo                 JSONNetworkMessageContentMask = 32
)

// String returns enumeration value as string.
func (v JSONNetworkMessageContentMask) String() string {
    switch v {
    case 0: 
        return "None"
    case 1: 
        return "NetworkMessageHeader"
    case 2: 
        return "DataSetMessageHeader"
    case 4: 
        return "SingleDataSetMessage"
    case 8: 
        return "PublisherID"
    case 16: 
        return "DataSetClassID"
    case 32: 
        return "ReplyTo"
    default:
        return ""
    }
}

// JSONDataSetMessageContentMask enumeration.
type JSONDataSetMessageContentMask int32

// JSONDataSetMessageContentMask enumeration.
const (
    JSONDataSetMessageContentMaskNone               JSONDataSetMessageContentMask = 0
    JSONDataSetMessageContentMaskDataSetWriterID    JSONDataSetMessageContentMask = 1
    JSONDataSetMessageContentMaskMetaDataVersion    JSONDataSetMessageContentMask = 2
    JSONDataSetMessageContentMaskSequenceNumber     JSONDataSetMessageContentMask = 4
    JSONDataSetMessageContentMaskTimestamp          JSONDataSetMessageContentMask = 8
    JSONDataSetMessageContentMaskStatus             JSONDataSetMessageContentMask = 16
)

// String returns enumeration value as string.
func (v JSONDataSetMessageContentMask) String() string {
    switch v {
    case 0: 
        return "None"
    case 1: 
        return "DataSetWriterID"
    case 2: 
        return "MetaDataVersion"
    case 4: 
        return "SequenceNumber"
    case 8: 
        return "Timestamp"
    case 16: 
        return "Status"
    default:
        return ""
    }
}

// BrokerTransportQoS enumeration.
type BrokerTransportQoS int32

// BrokerTransportQoS enumeration.
const (
    BrokerTransportQoSNotSpecified    BrokerTransportQoS = 0
    BrokerTransportQoSBestEffort      BrokerTransportQoS = 1
    BrokerTransportQoSAtLeastOnce     BrokerTransportQoS = 2
    BrokerTransportQoSAtMostOnce      BrokerTransportQoS = 3
    BrokerTransportQoSExactlyOnce     BrokerTransportQoS = 4
)

// String returns enumeration value as string.
func (v BrokerTransportQoS) String() string {
    switch v {
    case 0: 
        return "NotSpecified"
    case 1: 
        return "BestEffort"
    case 2: 
        return "AtLeastOnce"
    case 3: 
        return "AtMostOnce"
    case 4: 
        return "ExactlyOnce"
    default:
        return ""
    }
}

// DiagnosticsLevel enumeration.
type DiagnosticsLevel int32

// DiagnosticsLevel enumeration.
const (
    DiagnosticsLevelBasic       DiagnosticsLevel = 0
    DiagnosticsLevelAdvanced    DiagnosticsLevel = 1
    DiagnosticsLevelInfo        DiagnosticsLevel = 2
    DiagnosticsLevelLog         DiagnosticsLevel = 3
    DiagnosticsLevelDebug       DiagnosticsLevel = 4
)

// String returns enumeration value as string.
func (v DiagnosticsLevel) String() string {
    switch v {
    case 0: 
        return "Basic"
    case 1: 
        return "Advanced"
    case 2: 
        return "Info"
    case 3: 
        return "Log"
    case 4: 
        return "Debug"
    default:
        return ""
    }
}

// PubSubDiagnosticsCounterClassification enumeration.
type PubSubDiagnosticsCounterClassification int32

// PubSubDiagnosticsCounterClassification enumeration.
const (
    PubSubDiagnosticsCounterClassificationInformation    PubSubDiagnosticsCounterClassification = 0
    PubSubDiagnosticsCounterClassificationError          PubSubDiagnosticsCounterClassification = 1
)

// String returns enumeration value as string.
func (v PubSubDiagnosticsCounterClassification) String() string {
    switch v {
    case 0: 
        return "Information"
    case 1: 
        return "Error"
    default:
        return ""
    }
}

// IDType enumeration.
type IDType int32

// IDType enumeration.
const (
    IDTypeNumeric    IDType = 0
    IDTypeString     IDType = 1
    IDTypeGUID       IDType = 2
    IDTypeOpaque     IDType = 3
)

// String returns enumeration value as string.
func (v IDType) String() string {
    switch v {
    case 0: 
        return "Numeric"
    case 1: 
        return "String"
    case 2: 
        return "GUID"
    case 3: 
        return "Opaque"
    default:
        return ""
    }
}

// NodeClass enumeration.
type NodeClass int32

// NodeClass enumeration.
const (
    NodeClassUnspecified      NodeClass = 0
    NodeClassObject           NodeClass = 1
    NodeClassVariable         NodeClass = 2
    NodeClassMethod           NodeClass = 4
    NodeClassObjectType       NodeClass = 8
    NodeClassVariableType     NodeClass = 16
    NodeClassReferenceType    NodeClass = 32
    NodeClassDataType         NodeClass = 64
    NodeClassView             NodeClass = 128
)

// String returns enumeration value as string.
func (v NodeClass) String() string {
    switch v {
    case 0: 
        return "Unspecified"
    case 1: 
        return "Object"
    case 2: 
        return "Variable"
    case 4: 
        return "Method"
    case 8: 
        return "ObjectType"
    case 16: 
        return "VariableType"
    case 32: 
        return "ReferenceType"
    case 64: 
        return "DataType"
    case 128: 
        return "View"
    default:
        return ""
    }
}

// PermissionType enumeration.
type PermissionType int32

// PermissionType enumeration.
const (
    PermissionTypeNone                    PermissionType = 0
    PermissionTypeBrowse                  PermissionType = 1
    PermissionTypeReadRolePermissions     PermissionType = 2
    PermissionTypeWriteAttribute          PermissionType = 4
    PermissionTypeWriteRolePermissions    PermissionType = 8
    PermissionTypeWriteHistorizing        PermissionType = 16
    PermissionTypeRead                    PermissionType = 32
    PermissionTypeWrite                   PermissionType = 64
    PermissionTypeReadHistory             PermissionType = 128
    PermissionTypeInsertHistory           PermissionType = 256
    PermissionTypeModifyHistory           PermissionType = 512
    PermissionTypeDeleteHistory           PermissionType = 1024
    PermissionTypeReceiveEvents           PermissionType = 2048
    PermissionTypeCall                    PermissionType = 4096
    PermissionTypeAddReference            PermissionType = 8192
    PermissionTypeRemoveReference         PermissionType = 16384
    PermissionTypeDeleteNode              PermissionType = 32768
    PermissionTypeAddNode                 PermissionType = 65536
)

// String returns enumeration value as string.
func (v PermissionType) String() string {
    switch v {
    case 0: 
        return "None"
    case 1: 
        return "Browse"
    case 2: 
        return "ReadRolePermissions"
    case 4: 
        return "WriteAttribute"
    case 8: 
        return "WriteRolePermissions"
    case 16: 
        return "WriteHistorizing"
    case 32: 
        return "Read"
    case 64: 
        return "Write"
    case 128: 
        return "ReadHistory"
    case 256: 
        return "InsertHistory"
    case 512: 
        return "ModifyHistory"
    case 1024: 
        return "DeleteHistory"
    case 2048: 
        return "ReceiveEvents"
    case 4096: 
        return "Call"
    case 8192: 
        return "AddReference"
    case 16384: 
        return "RemoveReference"
    case 32768: 
        return "DeleteNode"
    case 65536: 
        return "AddNode"
    default:
        return ""
    }
}

// AccessLevelType enumeration.
type AccessLevelType int32

// AccessLevelType enumeration.
const (
    AccessLevelTypeNone              AccessLevelType = 0
    AccessLevelTypeCurrentRead       AccessLevelType = 1
    AccessLevelTypeCurrentWrite      AccessLevelType = 2
    AccessLevelTypeHistoryRead       AccessLevelType = 4
    AccessLevelTypeHistoryWrite      AccessLevelType = 8
    AccessLevelTypeSemanticChange    AccessLevelType = 16
    AccessLevelTypeStatusWrite       AccessLevelType = 32
    AccessLevelTypeTimestampWrite    AccessLevelType = 64
)

// String returns enumeration value as string.
func (v AccessLevelType) String() string {
    switch v {
    case 0: 
        return "None"
    case 1: 
        return "CurrentRead"
    case 2: 
        return "CurrentWrite"
    case 4: 
        return "HistoryRead"
    case 8: 
        return "HistoryWrite"
    case 16: 
        return "SemanticChange"
    case 32: 
        return "StatusWrite"
    case 64: 
        return "TimestampWrite"
    default:
        return ""
    }
}

// AccessLevelExType enumeration.
type AccessLevelExType int32

// AccessLevelExType enumeration.
const (
    AccessLevelExTypeNone                  AccessLevelExType = 0
    AccessLevelExTypeCurrentRead           AccessLevelExType = 1
    AccessLevelExTypeCurrentWrite          AccessLevelExType = 2
    AccessLevelExTypeHistoryRead           AccessLevelExType = 4
    AccessLevelExTypeHistoryWrite          AccessLevelExType = 8
    AccessLevelExTypeSemanticChange        AccessLevelExType = 16
    AccessLevelExTypeStatusWrite           AccessLevelExType = 32
    AccessLevelExTypeTimestampWrite        AccessLevelExType = 64
    AccessLevelExTypeNonatomicRead         AccessLevelExType = 256
    AccessLevelExTypeNonatomicWrite        AccessLevelExType = 512
    AccessLevelExTypeWriteFullArrayOnly    AccessLevelExType = 1024
)

// String returns enumeration value as string.
func (v AccessLevelExType) String() string {
    switch v {
    case 0: 
        return "None"
    case 1: 
        return "CurrentRead"
    case 2: 
        return "CurrentWrite"
    case 4: 
        return "HistoryRead"
    case 8: 
        return "HistoryWrite"
    case 16: 
        return "SemanticChange"
    case 32: 
        return "StatusWrite"
    case 64: 
        return "TimestampWrite"
    case 256: 
        return "NonatomicRead"
    case 512: 
        return "NonatomicWrite"
    case 1024: 
        return "WriteFullArrayOnly"
    default:
        return ""
    }
}

// EventNotifierType enumeration.
type EventNotifierType int32

// EventNotifierType enumeration.
const (
    EventNotifierTypeNone                 EventNotifierType = 0
    EventNotifierTypeSubscribeToEvents    EventNotifierType = 1
    EventNotifierTypeHistoryRead          EventNotifierType = 4
    EventNotifierTypeHistoryWrite         EventNotifierType = 8
)

// String returns enumeration value as string.
func (v EventNotifierType) String() string {
    switch v {
    case 0: 
        return "None"
    case 1: 
        return "SubscribeToEvents"
    case 4: 
        return "HistoryRead"
    case 8: 
        return "HistoryWrite"
    default:
        return ""
    }
}

// AccessRestrictionType enumeration.
type AccessRestrictionType int32

// AccessRestrictionType enumeration.
const (
    AccessRestrictionTypeNone                  AccessRestrictionType = 0
    AccessRestrictionTypeSigningRequired       AccessRestrictionType = 1
    AccessRestrictionTypeEncryptionRequired    AccessRestrictionType = 2
    AccessRestrictionTypeSessionRequired       AccessRestrictionType = 4
)

// String returns enumeration value as string.
func (v AccessRestrictionType) String() string {
    switch v {
    case 0: 
        return "None"
    case 1: 
        return "SigningRequired"
    case 2: 
        return "EncryptionRequired"
    case 4: 
        return "SessionRequired"
    default:
        return ""
    }
}

// StructureType enumeration.
type StructureType int32

// StructureType enumeration.
const (
    StructureTypeStructure                      StructureType = 0
    StructureTypeStructureWithOptionalFields    StructureType = 1
    StructureTypeUnion                          StructureType = 2
)

// String returns enumeration value as string.
func (v StructureType) String() string {
    switch v {
    case 0: 
        return "Structure"
    case 1: 
        return "StructureWithOptionalFields"
    case 2: 
        return "Union"
    default:
        return ""
    }
}

// ApplicationType enumeration.
type ApplicationType int32

// ApplicationType enumeration.
const (
    ApplicationTypeServer             ApplicationType = 0
    ApplicationTypeClient             ApplicationType = 1
    ApplicationTypeClientAndServer    ApplicationType = 2
    ApplicationTypeDiscoveryServer    ApplicationType = 3
)

// String returns enumeration value as string.
func (v ApplicationType) String() string {
    switch v {
    case 0: 
        return "Server"
    case 1: 
        return "Client"
    case 2: 
        return "ClientAndServer"
    case 3: 
        return "DiscoveryServer"
    default:
        return ""
    }
}

// MessageSecurityMode enumeration.
type MessageSecurityMode int32

// MessageSecurityMode enumeration.
const (
    MessageSecurityModeInvalid           MessageSecurityMode = 0
    MessageSecurityModeNone              MessageSecurityMode = 1
    MessageSecurityModeSign              MessageSecurityMode = 2
    MessageSecurityModeSignAndEncrypt    MessageSecurityMode = 3
)

// String returns enumeration value as string.
func (v MessageSecurityMode) String() string {
    switch v {
    case 0: 
        return "Invalid"
    case 1: 
        return "None"
    case 2: 
        return "Sign"
    case 3: 
        return "SignAndEncrypt"
    default:
        return ""
    }
}

// UserTokenType enumeration.
type UserTokenType int32

// UserTokenType enumeration.
const (
    UserTokenTypeAnonymous      UserTokenType = 0
    UserTokenTypeUserName       UserTokenType = 1
    UserTokenTypeCertificate    UserTokenType = 2
    UserTokenTypeIssuedToken    UserTokenType = 3
)

// String returns enumeration value as string.
func (v UserTokenType) String() string {
    switch v {
    case 0: 
        return "Anonymous"
    case 1: 
        return "UserName"
    case 2: 
        return "Certificate"
    case 3: 
        return "IssuedToken"
    default:
        return ""
    }
}

// SecurityTokenRequestType enumeration.
type SecurityTokenRequestType int32

// SecurityTokenRequestType enumeration.
const (
    SecurityTokenRequestTypeIssue    SecurityTokenRequestType = 0
    SecurityTokenRequestTypeRenew    SecurityTokenRequestType = 1
)

// String returns enumeration value as string.
func (v SecurityTokenRequestType) String() string {
    switch v {
    case 0: 
        return "Issue"
    case 1: 
        return "Renew"
    default:
        return ""
    }
}

// NodeAttributesMask enumeration.
type NodeAttributesMask int32

// NodeAttributesMask enumeration.
const (
    NodeAttributesMaskNone                       NodeAttributesMask = 0
    NodeAttributesMaskAccessLevel                NodeAttributesMask = 1
    NodeAttributesMaskArrayDimensions            NodeAttributesMask = 2
    NodeAttributesMaskBrowseName                 NodeAttributesMask = 4
    NodeAttributesMaskContainsNoLoops            NodeAttributesMask = 8
    NodeAttributesMaskDataType                   NodeAttributesMask = 16
    NodeAttributesMaskDescription                NodeAttributesMask = 32
    NodeAttributesMaskDisplayName                NodeAttributesMask = 64
    NodeAttributesMaskEventNotifier              NodeAttributesMask = 128
    NodeAttributesMaskExecutable                 NodeAttributesMask = 256
    NodeAttributesMaskHistorizing                NodeAttributesMask = 512
    NodeAttributesMaskInverseName                NodeAttributesMask = 1024
    NodeAttributesMaskIsAbstract                 NodeAttributesMask = 2048
    NodeAttributesMaskMinimumSamplingInterval    NodeAttributesMask = 4096
    NodeAttributesMaskNodeClass                  NodeAttributesMask = 8192
    NodeAttributesMaskNodeID                     NodeAttributesMask = 16384
    NodeAttributesMaskSymmetric                  NodeAttributesMask = 32768
    NodeAttributesMaskUserAccessLevel            NodeAttributesMask = 65536
    NodeAttributesMaskUserExecutable             NodeAttributesMask = 131072
    NodeAttributesMaskUserWriteMask              NodeAttributesMask = 262144
    NodeAttributesMaskValueRank                  NodeAttributesMask = 524288
    NodeAttributesMaskWriteMask                  NodeAttributesMask = 1048576
    NodeAttributesMaskValue                      NodeAttributesMask = 2097152
    NodeAttributesMaskDataTypeDefinition         NodeAttributesMask = 4194304
    NodeAttributesMaskRolePermissions            NodeAttributesMask = 8388608
    NodeAttributesMaskAccessRestrictions         NodeAttributesMask = 16777216
    NodeAttributesMaskAll                        NodeAttributesMask = 33554431
    NodeAttributesMaskBaseNode                   NodeAttributesMask = 26501220
    NodeAttributesMaskObject                     NodeAttributesMask = 26501348
    NodeAttributesMaskObjectType                 NodeAttributesMask = 26503268
    NodeAttributesMaskVariable                   NodeAttributesMask = 26571383
    NodeAttributesMaskVariableType               NodeAttributesMask = 28600438
    NodeAttributesMaskMethod                     NodeAttributesMask = 26632548
    NodeAttributesMaskReferenceType              NodeAttributesMask = 26537060
    NodeAttributesMaskView                       NodeAttributesMask = 26501356
)

// String returns enumeration value as string.
func (v NodeAttributesMask) String() string {
    switch v {
    case 0: 
        return "None"
    case 1: 
        return "AccessLevel"
    case 2: 
        return "ArrayDimensions"
    case 4: 
        return "BrowseName"
    case 8: 
        return "ContainsNoLoops"
    case 16: 
        return "DataType"
    case 32: 
        return "Description"
    case 64: 
        return "DisplayName"
    case 128: 
        return "EventNotifier"
    case 256: 
        return "Executable"
    case 512: 
        return "Historizing"
    case 1024: 
        return "InverseName"
    case 2048: 
        return "IsAbstract"
    case 4096: 
        return "MinimumSamplingInterval"
    case 8192: 
        return "NodeClass"
    case 16384: 
        return "NodeID"
    case 32768: 
        return "Symmetric"
    case 65536: 
        return "UserAccessLevel"
    case 131072: 
        return "UserExecutable"
    case 262144: 
        return "UserWriteMask"
    case 524288: 
        return "ValueRank"
    case 1048576: 
        return "WriteMask"
    case 2097152: 
        return "Value"
    case 4194304: 
        return "DataTypeDefinition"
    case 8388608: 
        return "RolePermissions"
    case 16777216: 
        return "AccessRestrictions"
    case 33554431: 
        return "All"
    case 26501220: 
        return "BaseNode"
    case 26501348: 
        return "Object"
    case 26503268: 
        return "ObjectType"
    case 26571383: 
        return "Variable"
    case 28600438: 
        return "VariableType"
    case 26632548: 
        return "Method"
    case 26537060: 
        return "ReferenceType"
    case 26501356: 
        return "View"
    default:
        return ""
    }
}

// AttributeWriteMask enumeration.
type AttributeWriteMask int32

// AttributeWriteMask enumeration.
const (
    AttributeWriteMaskNone                       AttributeWriteMask = 0
    AttributeWriteMaskAccessLevel                AttributeWriteMask = 1
    AttributeWriteMaskArrayDimensions            AttributeWriteMask = 2
    AttributeWriteMaskBrowseName                 AttributeWriteMask = 4
    AttributeWriteMaskContainsNoLoops            AttributeWriteMask = 8
    AttributeWriteMaskDataType                   AttributeWriteMask = 16
    AttributeWriteMaskDescription                AttributeWriteMask = 32
    AttributeWriteMaskDisplayName                AttributeWriteMask = 64
    AttributeWriteMaskEventNotifier              AttributeWriteMask = 128
    AttributeWriteMaskExecutable                 AttributeWriteMask = 256
    AttributeWriteMaskHistorizing                AttributeWriteMask = 512
    AttributeWriteMaskInverseName                AttributeWriteMask = 1024
    AttributeWriteMaskIsAbstract                 AttributeWriteMask = 2048
    AttributeWriteMaskMinimumSamplingInterval    AttributeWriteMask = 4096
    AttributeWriteMaskNodeClass                  AttributeWriteMask = 8192
    AttributeWriteMaskNodeID                     AttributeWriteMask = 16384
    AttributeWriteMaskSymmetric                  AttributeWriteMask = 32768
    AttributeWriteMaskUserAccessLevel            AttributeWriteMask = 65536
    AttributeWriteMaskUserExecutable             AttributeWriteMask = 131072
    AttributeWriteMaskUserWriteMask              AttributeWriteMask = 262144
    AttributeWriteMaskValueRank                  AttributeWriteMask = 524288
    AttributeWriteMaskWriteMask                  AttributeWriteMask = 1048576
    AttributeWriteMaskValueForVariableType       AttributeWriteMask = 2097152
    AttributeWriteMaskDataTypeDefinition         AttributeWriteMask = 4194304
    AttributeWriteMaskRolePermissions            AttributeWriteMask = 8388608
    AttributeWriteMaskAccessRestrictions         AttributeWriteMask = 16777216
    AttributeWriteMaskAccessLevelEx              AttributeWriteMask = 33554432
)

// String returns enumeration value as string.
func (v AttributeWriteMask) String() string {
    switch v {
    case 0: 
        return "None"
    case 1: 
        return "AccessLevel"
    case 2: 
        return "ArrayDimensions"
    case 4: 
        return "BrowseName"
    case 8: 
        return "ContainsNoLoops"
    case 16: 
        return "DataType"
    case 32: 
        return "Description"
    case 64: 
        return "DisplayName"
    case 128: 
        return "EventNotifier"
    case 256: 
        return "Executable"
    case 512: 
        return "Historizing"
    case 1024: 
        return "InverseName"
    case 2048: 
        return "IsAbstract"
    case 4096: 
        return "MinimumSamplingInterval"
    case 8192: 
        return "NodeClass"
    case 16384: 
        return "NodeID"
    case 32768: 
        return "Symmetric"
    case 65536: 
        return "UserAccessLevel"
    case 131072: 
        return "UserExecutable"
    case 262144: 
        return "UserWriteMask"
    case 524288: 
        return "ValueRank"
    case 1048576: 
        return "WriteMask"
    case 2097152: 
        return "ValueForVariableType"
    case 4194304: 
        return "DataTypeDefinition"
    case 8388608: 
        return "RolePermissions"
    case 16777216: 
        return "AccessRestrictions"
    case 33554432: 
        return "AccessLevelEx"
    default:
        return ""
    }
}

// BrowseDirection enumeration.
type BrowseDirection int32

// BrowseDirection enumeration.
const (
    BrowseDirectionForward    BrowseDirection = 0
    BrowseDirectionInverse    BrowseDirection = 1
    BrowseDirectionBoth       BrowseDirection = 2
    BrowseDirectionInvalid    BrowseDirection = 3
)

// String returns enumeration value as string.
func (v BrowseDirection) String() string {
    switch v {
    case 0: 
        return "Forward"
    case 1: 
        return "Inverse"
    case 2: 
        return "Both"
    case 3: 
        return "Invalid"
    default:
        return ""
    }
}

// BrowseResultMask enumeration.
type BrowseResultMask int32

// BrowseResultMask enumeration.
const (
    BrowseResultMaskNone                 BrowseResultMask = 0
    BrowseResultMaskReferenceTypeID      BrowseResultMask = 1
    BrowseResultMaskIsForward            BrowseResultMask = 2
    BrowseResultMaskNodeClass            BrowseResultMask = 4
    BrowseResultMaskBrowseName           BrowseResultMask = 8
    BrowseResultMaskDisplayName          BrowseResultMask = 16
    BrowseResultMaskTypeDefinition       BrowseResultMask = 32
    BrowseResultMaskAll                  BrowseResultMask = 63
    BrowseResultMaskReferenceTypeInfo    BrowseResultMask = 3
    BrowseResultMaskTargetInfo           BrowseResultMask = 60
)

// String returns enumeration value as string.
func (v BrowseResultMask) String() string {
    switch v {
    case 0: 
        return "None"
    case 1: 
        return "ReferenceTypeID"
    case 2: 
        return "IsForward"
    case 4: 
        return "NodeClass"
    case 8: 
        return "BrowseName"
    case 16: 
        return "DisplayName"
    case 32: 
        return "TypeDefinition"
    case 63: 
        return "All"
    case 3: 
        return "ReferenceTypeInfo"
    case 60: 
        return "TargetInfo"
    default:
        return ""
    }
}

// FilterOperator enumeration.
type FilterOperator int32

// FilterOperator enumeration.
const (
    FilterOperatorEquals                FilterOperator = 0
    FilterOperatorIsNull                FilterOperator = 1
    FilterOperatorGreaterThan           FilterOperator = 2
    FilterOperatorLessThan              FilterOperator = 3
    FilterOperatorGreaterThanOrEqual    FilterOperator = 4
    FilterOperatorLessThanOrEqual       FilterOperator = 5
    FilterOperatorLike                  FilterOperator = 6
    FilterOperatorNot                   FilterOperator = 7
    FilterOperatorBetween               FilterOperator = 8
    FilterOperatorInList                FilterOperator = 9
    FilterOperatorAnd                   FilterOperator = 10
    FilterOperatorOr                    FilterOperator = 11
    FilterOperatorCast                  FilterOperator = 12
    FilterOperatorInView                FilterOperator = 13
    FilterOperatorOfType                FilterOperator = 14
    FilterOperatorRelatedTo             FilterOperator = 15
    FilterOperatorBitwiseAnd            FilterOperator = 16
    FilterOperatorBitwiseOr             FilterOperator = 17
)

// String returns enumeration value as string.
func (v FilterOperator) String() string {
    switch v {
    case 0: 
        return "Equals"
    case 1: 
        return "IsNull"
    case 2: 
        return "GreaterThan"
    case 3: 
        return "LessThan"
    case 4: 
        return "GreaterThanOrEqual"
    case 5: 
        return "LessThanOrEqual"
    case 6: 
        return "Like"
    case 7: 
        return "Not"
    case 8: 
        return "Between"
    case 9: 
        return "InList"
    case 10: 
        return "And"
    case 11: 
        return "Or"
    case 12: 
        return "Cast"
    case 13: 
        return "InView"
    case 14: 
        return "OfType"
    case 15: 
        return "RelatedTo"
    case 16: 
        return "BitwiseAnd"
    case 17: 
        return "BitwiseOr"
    default:
        return ""
    }
}

// TimestampsToReturn enumeration.
type TimestampsToReturn int32

// TimestampsToReturn enumeration.
const (
    TimestampsToReturnSource     TimestampsToReturn = 0
    TimestampsToReturnServer     TimestampsToReturn = 1
    TimestampsToReturnBoth       TimestampsToReturn = 2
    TimestampsToReturnNeither    TimestampsToReturn = 3
    TimestampsToReturnInvalid    TimestampsToReturn = 4
)

// String returns enumeration value as string.
func (v TimestampsToReturn) String() string {
    switch v {
    case 0: 
        return "Source"
    case 1: 
        return "Server"
    case 2: 
        return "Both"
    case 3: 
        return "Neither"
    case 4: 
        return "Invalid"
    default:
        return ""
    }
}

// HistoryUpdateType enumeration.
type HistoryUpdateType int32

// HistoryUpdateType enumeration.
const (
    HistoryUpdateTypeInsert     HistoryUpdateType = 1
    HistoryUpdateTypeReplace    HistoryUpdateType = 2
    HistoryUpdateTypeUpdate     HistoryUpdateType = 3
    HistoryUpdateTypeDelete     HistoryUpdateType = 4
)

// String returns enumeration value as string.
func (v HistoryUpdateType) String() string {
    switch v {
    case 1: 
        return "Insert"
    case 2: 
        return "Replace"
    case 3: 
        return "Update"
    case 4: 
        return "Delete"
    default:
        return ""
    }
}

// PerformUpdateType enumeration.
type PerformUpdateType int32

// PerformUpdateType enumeration.
const (
    PerformUpdateTypeInsert     PerformUpdateType = 1
    PerformUpdateTypeReplace    PerformUpdateType = 2
    PerformUpdateTypeUpdate     PerformUpdateType = 3
    PerformUpdateTypeRemove     PerformUpdateType = 4
)

// String returns enumeration value as string.
func (v PerformUpdateType) String() string {
    switch v {
    case 1: 
        return "Insert"
    case 2: 
        return "Replace"
    case 3: 
        return "Update"
    case 4: 
        return "Remove"
    default:
        return ""
    }
}

// MonitoringMode enumeration.
type MonitoringMode int32

// MonitoringMode enumeration.
const (
    MonitoringModeDisabled     MonitoringMode = 0
    MonitoringModeSampling     MonitoringMode = 1
    MonitoringModeReporting    MonitoringMode = 2
)

// String returns enumeration value as string.
func (v MonitoringMode) String() string {
    switch v {
    case 0: 
        return "Disabled"
    case 1: 
        return "Sampling"
    case 2: 
        return "Reporting"
    default:
        return ""
    }
}

// DataChangeTrigger enumeration.
type DataChangeTrigger int32

// DataChangeTrigger enumeration.
const (
    DataChangeTriggerStatus                  DataChangeTrigger = 0
    DataChangeTriggerStatusValue             DataChangeTrigger = 1
    DataChangeTriggerStatusValueTimestamp    DataChangeTrigger = 2
)

// String returns enumeration value as string.
func (v DataChangeTrigger) String() string {
    switch v {
    case 0: 
        return "Status"
    case 1: 
        return "StatusValue"
    case 2: 
        return "StatusValueTimestamp"
    default:
        return ""
    }
}

// DeadbandType enumeration.
type DeadbandType int32

// DeadbandType enumeration.
const (
    DeadbandTypeNone        DeadbandType = 0
    DeadbandTypeAbsolute    DeadbandType = 1
    DeadbandTypePercent     DeadbandType = 2
)

// String returns enumeration value as string.
func (v DeadbandType) String() string {
    switch v {
    case 0: 
        return "None"
    case 1: 
        return "Absolute"
    case 2: 
        return "Percent"
    default:
        return ""
    }
}

// RedundancySupport enumeration.
type RedundancySupport int32

// RedundancySupport enumeration.
const (
    RedundancySupportNone              RedundancySupport = 0
    RedundancySupportCold              RedundancySupport = 1
    RedundancySupportWarm              RedundancySupport = 2
    RedundancySupportHot               RedundancySupport = 3
    RedundancySupportTransparent       RedundancySupport = 4
    RedundancySupportHotAndMirrored    RedundancySupport = 5
)

// String returns enumeration value as string.
func (v RedundancySupport) String() string {
    switch v {
    case 0: 
        return "None"
    case 1: 
        return "Cold"
    case 2: 
        return "Warm"
    case 3: 
        return "Hot"
    case 4: 
        return "Transparent"
    case 5: 
        return "HotAndMirrored"
    default:
        return ""
    }
}

// ServerState enumeration.
type ServerState int32

// ServerState enumeration.
const (
    ServerStateRunning               ServerState = 0
    ServerStateFailed                ServerState = 1
    ServerStateNoConfiguration       ServerState = 2
    ServerStateSuspended             ServerState = 3
    ServerStateShutdown              ServerState = 4
    ServerStateTest                  ServerState = 5
    ServerStateCommunicationFault    ServerState = 6
    ServerStateUnknown               ServerState = 7
)

// String returns enumeration value as string.
func (v ServerState) String() string {
    switch v {
    case 0: 
        return "Running"
    case 1: 
        return "Failed"
    case 2: 
        return "NoConfiguration"
    case 3: 
        return "Suspended"
    case 4: 
        return "Shutdown"
    case 5: 
        return "Test"
    case 6: 
        return "CommunicationFault"
    case 7: 
        return "Unknown"
    default:
        return ""
    }
}

// ModelChangeStructureVerbMask enumeration.
type ModelChangeStructureVerbMask int32

// ModelChangeStructureVerbMask enumeration.
const (
    ModelChangeStructureVerbMaskNodeAdded           ModelChangeStructureVerbMask = 1
    ModelChangeStructureVerbMaskNodeDeleted         ModelChangeStructureVerbMask = 2
    ModelChangeStructureVerbMaskReferenceAdded      ModelChangeStructureVerbMask = 4
    ModelChangeStructureVerbMaskReferenceDeleted    ModelChangeStructureVerbMask = 8
    ModelChangeStructureVerbMaskDataTypeChanged     ModelChangeStructureVerbMask = 16
)

// String returns enumeration value as string.
func (v ModelChangeStructureVerbMask) String() string {
    switch v {
    case 1: 
        return "NodeAdded"
    case 2: 
        return "NodeDeleted"
    case 4: 
        return "ReferenceAdded"
    case 8: 
        return "ReferenceDeleted"
    case 16: 
        return "DataTypeChanged"
    default:
        return ""
    }
}

// AxisScaleEnumeration enumeration.
type AxisScaleEnumeration int32

// AxisScaleEnumeration enumeration.
const (
    AxisScaleEnumerationLinear    AxisScaleEnumeration = 0
    AxisScaleEnumerationLog       AxisScaleEnumeration = 1
    AxisScaleEnumerationLn        AxisScaleEnumeration = 2
)

// String returns enumeration value as string.
func (v AxisScaleEnumeration) String() string {
    switch v {
    case 0: 
        return "Linear"
    case 1: 
        return "Log"
    case 2: 
        return "Ln"
    default:
        return ""
    }
}

// ExceptionDeviationFormat enumeration.
type ExceptionDeviationFormat int32

// ExceptionDeviationFormat enumeration.
const (
    ExceptionDeviationFormatAbsoluteValue       ExceptionDeviationFormat = 0
    ExceptionDeviationFormatPercentOfValue      ExceptionDeviationFormat = 1
    ExceptionDeviationFormatPercentOfRange      ExceptionDeviationFormat = 2
    ExceptionDeviationFormatPercentOfEURange    ExceptionDeviationFormat = 3
    ExceptionDeviationFormatUnknown             ExceptionDeviationFormat = 4
)

// String returns enumeration value as string.
func (v ExceptionDeviationFormat) String() string {
    switch v {
    case 0: 
        return "AbsoluteValue"
    case 1: 
        return "PercentOfValue"
    case 2: 
        return "PercentOfRange"
    case 3: 
        return "PercentOfEURange"
    case 4: 
        return "Unknown"
    default:
        return ""
    }
}