/RouterOS.AutoObjects/rosobjects.cs

Large files files are truncated, but you can click here to view the full file

using System;

using System.Net;

using RouterOS.API;

using RouterOS.DataTypes;

using RouterOS.Serialization;



namespace RouterOS

{

	[RosObject("certificate", CanAdd=true, CanSet=true, CanGet=true, CanRemove=true)]

	public class Certificate : RosItemObject<Certificate>

	{

		// Whether the key is used for building or verifying certificate chains

		[RosValue("ca")]

		public Boolean? Ca { get; set; }

		

		// E-mail address

		[RosValue("email")]

		public String Email { get; set; }

		

		// Issuer of the certificate

		[RosValue("issuer")]

		public String Issuer { get; set; }

		

		// Reference name

		[RosValue("name")]

		public String Name { get; set; }

		

		// Holder (subject) of the certificate

		[RosValue("subject")]

		public String Subject { get; set; }

		

		[RosValue("alias", IsDynamic=true)]

		public String Alias { get; set; }

		

		[RosValue("decrypted-private-key", IsDynamic=true)]

		public String DecryptedPrivateKey { get; set; }

		

		[RosValue("dsa", IsDynamic=true)]

		public String Dsa { get; set; }

		

		[RosValue("invalid-after", IsDynamic=true)]

		public DateTime? InvalidAfter { get; set; }

		

		[RosValue("invalid-before", IsDynamic=true)]

		public DateTime? InvalidBefore { get; set; }

		

		[RosValue("private-key", IsDynamic=true)]

		public String PrivateKey { get; set; }

		

		[RosValue("rsa", IsDynamic=true)]

		public String Rsa { get; set; }

		

		[RosValue("serial-number", IsDynamic=true)]

		public String SerialNumber { get; set; }

		

		public static Certificate Parse(string str, Connection conn)

		{

			if(string.IsNullOrEmpty(str))

				return null;

			Certificate obj = new Certificate();

			obj.FindByName(conn, str);

			return obj;

		}

		

		public override string ToString() { return Name.ToString(); }

		

	}

	[RosObject("driver", CanAdd=true, CanSet=true, CanGet=true, CanRemove=true)]

	public class Driver : RosItemObject<Driver>

	{

		// IO port base address

		[RosValue("io")]

		public Int32? Io { get; set; }

		

		// IRQ number

		[RosValue("irq")]

		public Int32? Irq { get; set; }

		

		public enum IsdnProtocolEnum

		{

			[RosValue("euro")]

			Euro,

			[RosValue("german")]

			German,

		}

		

		// ISDN line protocol

		[RosValue("isdn-protocol")]

		public IsdnProtocolEnum? IsdnProtocol { get; set; }

		

		// Shared Memory base address

		[RosValue("memory")]

		public Int32? Memory { get; set; }

		

		public enum NameEnum

		{

			[RosValue("3c509")]

			E3c509,

			[RosValue("lance")]

			Lance,

			[RosValue("ne2k-isa")]

			Ne2kIsa,

		}

		

		// Driver name

		[RosValue("name")]

		public NameEnum? Name { get; set; }

		

		[RosValue("driver", IsDynamic=true)]

		public String DriverName { get; set; }

		

		[RosValue("dynamic", IsDynamic=true)]

		public String Dynamic { get; set; }

		

		[RosValue("invalid", IsDynamic=true)]

		public String Invalid { get; set; }

		

		public static Driver Parse(string str, Connection conn)

		{

			if(string.IsNullOrEmpty(str))

				return null;

			Driver obj = new Driver();

			obj.FindByName(conn, str);

			return obj;

		}

		

		public override string ToString() { return Name.ToString(); }

		

	}

	[RosObject("file", CanAdd=true, CanSet=true, CanGet=true, CanRemove=true)]

	public class File : RosItemObject<File>

	{

		// Content of the file

		[RosValue("contents")]

		public String Contents { get; set; }

		

		[RosValue("creation-time", IsDynamic=true)]

		public DateTime? CreationTime { get; set; }

		

		[RosValue("name", IsDynamic=true)]

		public String Name { get; set; }

		

		[RosValue("package-architecture", IsDynamic=true)]

		public String PackageArchitecture { get; set; }

		

		[RosValue("package-build-time", IsDynamic=true)]

		public DateTime? PackageBuildTime { get; set; }

		

		[RosValue("package-name", IsDynamic=true)]

		public String PackageName { get; set; }

		

		[RosValue("package-version", IsDynamic=true)]

		public String PackageVersion { get; set; }

		

		[RosValue("size", IsDynamic=true)]

		public Int64? Size { get; set; }

		

		[RosValue("type", IsDynamic=true)]

		public String Type { get; set; }

		

		public static File Parse(string str, Connection conn)

		{

			if(string.IsNullOrEmpty(str))

				return null;

			File obj = new File();

			obj.FindByName(conn, str);

			return obj;

		}

		

		public override string ToString() { return Name.ToString(); }

		

	}

	[RosObject("interface", CanSet=true, CanGet=true)]

	public class Interface : RosItemObject<Interface>

	{

		// Short description of the item

		[RosValue("comment")]

		public String Comment { get; set; }

		

		// Defines whether item is ignored or used

		[RosValue("disabled")]

		public Boolean? Disabled { get; set; }

		

		[RosValue("l2mtu")]

		public UInt16? L2mtu { get; set; }

		

		// Maximum Transmit Unit

		[RosValue("mtu")]

		public UInt16? Mtu { get; set; }

		

		// Interface name

		[RosValue("name")]

		public String Name { get; set; }

		

		[RosValue("bytes", IsDynamic=true)]

		public Int64? Bytes { get; set; }

		

		[RosValue("drops", IsDynamic=true)]

		public Int32? Drops { get; set; }

		

		[RosValue("dynamic", IsDynamic=true)]

		public String Dynamic { get; set; }

		

		[RosValue("errors", IsDynamic=true)]

		public Int32? Errors { get; set; }

		

		[RosValue("packets", IsDynamic=true)]

		public Int64? Packets { get; set; }

		

		[RosValue("running", IsDynamic=true)]

		public String Running { get; set; }

		

		[RosValue("slave", IsDynamic=true)]

		public String Slave { get; set; }

		

		[RosValue("type", IsDynamic=true)]

		public String Type { get; set; }

		

		public static Interface Parse(string str, Connection conn)

		{

			if(string.IsNullOrEmpty(str))

				return null;

			Interface obj = new Interface();

			obj.FindByName(conn, str);

			return obj;

		}

		

		public override string ToString() { return Name.ToString(); }

		

	}

	[RosObject("interface bonding", CanAdd=true, CanSet=true, CanGet=true, CanRemove=true)]

	public class InterfaceBonding : RosItemObject<InterfaceBonding>

	{

		public enum ArpEnum

		{

			[RosValue("disabled")]

			Disabled,

			[RosValue("enabled")]

			Enabled,

			[RosValue("proxy-arp")]

			ProxyArp,

			[RosValue("reply-only")]

			ReplyOnly,

		}

		

		// Address Resolution Protocol

		[RosValue("arp")]

		public ArpEnum? Arp { get; set; }

		

		// Time in milliseconds for monitoring ARP requests

		[RosValue("arp-interval")]

		public TimeSpan? ArpInterval { get; set; }

		

		// IP addresses for monitoring

		[RosValue("arp-ip-targets")]

		public IPAddress[] ArpIpTargets { get; set; }

		

		// Short description of the item

		[RosValue("comment")]

		public String Comment { get; set; }

		

		// Defines whether item is ignored or used

		[RosValue("disabled")]

		public Boolean? Disabled { get; set; }

		

		// Time period the interface is disabled  if a link failure has been detected

		[RosValue("down-delay")]

		public TimeSpan? DownDelay { get; set; }

		

		public enum LacpRateEnum

		{

			[RosValue("1sec")]

			E1sec,

			[RosValue("30secs")]

			E30secs,

		}

		

		// Link Aggregation Control Protocol rate specifies how often to exchange with LACPDUs between bonding peer

		[RosValue("lacp-rate")]

		public LacpRateEnum? LacpRate { get; set; }

		

		public enum LinkMonitoringEnum

		{

			[RosValue("arp")]

			Arp,

			[RosValue("mii-type1")]

			MiiType1,

			[RosValue("mii-type2")]

			MiiType2,

			[RosValue("none")]

			None,

		}

		

		// Method for monitoring the link

		[RosValue("link-monitoring")]

		public LinkMonitoringEnum? LinkMonitoring { get; set; }

		

		// Time in milliseconds for monitoring mii-type link

		[RosValue("mii-interval")]

		public TimeSpan? MiiInterval { get; set; }

		

		// Interface bonding mode

		[RosValue("mode")]

		public String Mode { get; set; }

		

		// Maximum Transmit Unit

		[RosValue("mtu")]

		public UInt16? Mtu { get; set; }

		

		// Interface name

		[RosValue("name")]

		public String Name { get; set; }

		

		public enum MasterPortEnum

		{

			[RosValue("none")]

			None,

		}

		

		public struct PrimaryType 

                { 

                    private object value; 

                    public MasterPortEnum? MasterPort 

                { 

                    get { return value as MasterPortEnum?; } 

                    set { this.value = value; } 

                } 

                public static implicit operator PrimaryType(MasterPortEnum? value) 

                { 

                    return new PrimaryType() { value = value }; 

                }public RouterOS.Interface Slave 

                { 

                    get { return value as RouterOS.Interface; } 

                    set { this.value = value; } 

                } 

                public static implicit operator PrimaryType(RouterOS.Interface value) 

                { 

                    return new PrimaryType() { value = value }; 

                } 

                    public static PrimaryType Parse(string str, Connection conn)

                    {

                        

                try { return new PrimaryType() { value = TypeFormatter.ConvertFromString<MasterPortEnum>(str, conn) }; }

                catch(Exception) { }

                try { return new PrimaryType() { value = TypeFormatter.ConvertFromString<RouterOS.Interface>(str, conn) }; }

                catch(Exception) { }

                        throw new NotSupportedException();

                    }

                    public override string ToString() { return value != null ? value.ToString() : null; } 

                }

		// Slave that will be used in active-backup mode as active link

		[RosValue("primary")]

		public PrimaryType? Primary { get; set; }

		

		// Interfaces that are used in bonding

		[RosValue("slaves")]

		public RouterOS.Interface[] Slaves { get; set; }

		

		public enum TransmitHashPolicyEnum

		{

			[RosValue("layer-2")]

			Layer2,

			[RosValue("layer-2-and-3")]

			Layer2And3,

			[RosValue("layer-3-and-4")]

			Layer3And4,

		}

		

		[RosValue("transmit-hash-policy")]

		public TransmitHashPolicyEnum? TransmitHashPolicy { get; set; }

		

		// Time period the interface is disabled if a link has been brought up

		[RosValue("up-delay")]

		public TimeSpan? UpDelay { get; set; }

		

		[RosValue("mac-address", IsDynamic=true)]

		public MACAddress? MacAddress { get; set; }

		

		[RosValue("running", IsDynamic=true)]

		public String Running { get; set; }

		

		public static InterfaceBonding Parse(string str, Connection conn)

		{

			if(string.IsNullOrEmpty(str))

				return null;

			InterfaceBonding obj = new InterfaceBonding();

			obj.FindByName(conn, str);

			return obj;

		}

		

		public override string ToString() { return Name.ToString(); }

		

	}

	[RosObject("interface bridge", CanAdd=true, CanSet=true, CanGet=true, CanRemove=true)]

	public class InterfaceBridge : RosItemObject<InterfaceBridge>

	{

		[RosValue("admin-mac")]

		public MACAddress? AdminMac { get; set; }

		

		public enum AgeingTimeEnum

		{

			[RosValue("AgeingTime")]

			AgeingTime,

		}

		

		// Time the information about host will be kept in the the data base

		[RosValue("ageing-time")]

		public AgeingTimeEnum? AgeingTime { get; set; }

		

		public enum ArpEnum

		{

			[RosValue("disabled")]

			Disabled,

			[RosValue("enabled")]

			Enabled,

			[RosValue("proxy-arp")]

			ProxyArp,

			[RosValue("reply-only")]

			ReplyOnly,

		}

		

		// Address Resolution Protocol

		[RosValue("arp")]

		public ArpEnum? Arp { get; set; }

		

		[RosValue("auto-mac")]

		public Boolean? AutoMac { get; set; }

		

		// Short description of the item

		[RosValue("comment")]

		public String Comment { get; set; }

		

		// Defines whether item is ignored or used

		[RosValue("disabled")]

		public Boolean? Disabled { get; set; }

		

		public enum ForwardDelayEnum

		{

			[RosValue("ForwardDelay")]

			ForwardDelay,

		}

		

		// Time which is spent in listening/learning state

		[RosValue("forward-delay")]

		public ForwardDelayEnum? ForwardDelay { get; set; }

		

		[RosValue("l2mtu")]

		public UInt16? L2mtu { get; set; }

		

		public enum MaxMessageAgeEnum

		{

			[RosValue("MaxMessageAge")]

			MaxMessageAge,

		}

		

		// Time to remember Hello messages received from other bridges

		[RosValue("max-message-age")]

		public MaxMessageAgeEnum? MaxMessageAge { get; set; }

		

		// Maximum Transmit Unit

		[RosValue("mtu")]

		public UInt16? Mtu { get; set; }

		

		// Bridge name

		[RosValue("name")]

		public String Name { get; set; }

		

		// Bridge interface priority

		[RosValue("priority")]

		public Int32? Priority { get; set; }

		

		public enum ProtocolModeEnum

		{

			[RosValue("none")]

			None,

			[RosValue("rstp")]

			Rstp,

			[RosValue("stp")]

			Stp,

		}

		

		[RosValue("protocol-mode")]

		public ProtocolModeEnum? ProtocolMode { get; set; }

		

		[RosValue("transmit-hold-count")]

		public Int32? TransmitHoldCount { get; set; }

		

		[RosValue("mac-address", IsDynamic=true)]

		public MACAddress? MacAddress { get; set; }

		

		[RosValue("running", IsDynamic=true)]

		public String Running { get; set; }

		

		public static InterfaceBridge Parse(string str, Connection conn)

		{

			if(string.IsNullOrEmpty(str))

				return null;

			InterfaceBridge obj = new InterfaceBridge();

			obj.FindByName(conn, str);

			return obj;

		}

		

		public override string ToString() { return Name.ToString(); }

		

	}

	[RosObject("interface bridge calea", CanAdd=true, CanSet=true, CanMove=true, CanGet=true, CanRemove=true, CanUnset=true)]

	public class InterfaceBridgeCalea : RosItemObject<InterfaceBridgeCalea>

	{

		public enum ActionEnum

		{

			[RosValue("sniff")]

			Sniff,

			[RosValue("sniff-pc")]

			SniffPc,

		}

		

		// Action to undertake if the packet matches the rule

		[RosValue("action")]

		public ActionEnum? Action { get; set; }

		

		// ARP destination address

		[RosValue("arp-dst-address", CanUnset=true)]

		public String ArpDstAddress { get; set; }

		

		// ARP destination MAC address

		[RosValue("arp-dst-mac-address", CanUnset=true)]

		public String ArpDstMacAddress { get; set; }

		

		[RosValue("arp-gratuitous", CanUnset=true)]

		public Boolean? ArpGratuitous { get; set; }

		

		// The hardware type

		[RosValue("arp-hardware-type", CanUnset=true)]

		public String ArpHardwareType { get; set; }

		

		// The ARP opcode

		[RosValue("arp-opcode", CanUnset=true)]

		public String ArpOpcode { get; set; }

		

		// ARP packet type

		[RosValue("arp-packet-type", CanUnset=true)]

		public String ArpPacketType { get; set; }

		

		// ARP source address

		[RosValue("arp-src-address", CanUnset=true)]

		public String ArpSrcAddress { get; set; }

		

		// ARP source MAC address

		[RosValue("arp-src-mac-address", CanUnset=true)]

		public String ArpSrcMacAddress { get; set; }

		

		public enum ChainEnum

		{

			[RosValue("forward")]

			Forward,

			[RosValue("input")]

			Input,

			[RosValue("output")]

			Output,

		}

		

		// Chain name

		[RosValue("chain")]

		public ChainEnum? Chain { get; set; }

		

		// Short description of the item

		[RosValue("comment")]

		public String Comment { get; set; }

		

		// Defines whether item is ignored or used

		[RosValue("disabled")]

		public Boolean? Disabled { get; set; }

		

		// Destination address

		[RosValue("dst-address", CanUnset=true)]

		public String DstAddress { get; set; }

		

		// Destination MAC address

		[RosValue("dst-mac-address", CanUnset=true)]

		public String DstMacAddress { get; set; }

		

		// Destination port

		[RosValue("dst-port", CanUnset=true)]

		public String DstPort { get; set; }

		

		// Bridge interface the packet is coming in

		[RosValue("in-bridge", CanUnset=true)]

		public String InBridge { get; set; }

		

		// Interface name packets are coming into the bridge

		[RosValue("in-interface", CanUnset=true)]

		public String InInterface { get; set; }

		

		[RosValue("ingress-priority", CanUnset=true)]

		public String IngressPriority { get; set; }

		

		// IP protocol name

		[RosValue("ip-protocol", CanUnset=true)]

		public String IpProtocol { get; set; }

		

		// Restricts packet match rate to a given limit

		[RosValue("limit", CanUnset=true)]

		public String Limit { get; set; }

		

		// Defines the prefix to be printed before the logging information

		[RosValue("log-prefix")]

		public String LogPrefix { get; set; }

		

		// Protocol name  or number

		[RosValue("mac-protocol", CanUnset=true)]

		public String MacProtocol { get; set; }

		

		// Bridge interface the packet is going out

		[RosValue("out-bridge", CanUnset=true)]

		public String OutBridge { get; set; }

		

		// Interface name packets are leaving the bridge

		[RosValue("out-interface", CanUnset=true)]

		public String OutInterface { get; set; }

		

		[RosValue("packet-mark", CanUnset=true)]

		public String PacketMark { get; set; }

		

		// Packet type

		[RosValue("packet-type", CanUnset=true)]

		public String PacketType { get; set; }

		

		[RosValue("sniff-id")]

		public Int32? SniffId { get; set; }

		

		[RosValue("sniff-target")]

		public IPAddress SniffTarget { get; set; }

		

		[RosValue("sniff-target-port")]

		public Int32? SniffTargetPort { get; set; }

		

		// Source address

		[RosValue("src-address", CanUnset=true)]

		public String SrcAddress { get; set; }

		

		// Source MAC address

		[RosValue("src-mac-address", CanUnset=true)]

		public String SrcMacAddress { get; set; }

		

		// Source port

		[RosValue("src-port", CanUnset=true)]

		public String SrcPort { get; set; }

		

		// BPDU flags

		[RosValue("stp-flags", CanUnset=true)]

		public String StpFlags { get; set; }

		

		// Forward delay timer

		[RosValue("stp-forward-delay", CanUnset=true)]

		public String StpForwardDelay { get; set; }

		

		// STP hello packets time

		[RosValue("stp-hello-time", CanUnset=true)]

		public String StpHelloTime { get; set; }

		

		// STP maximum age

		[RosValue("stp-max-age", CanUnset=true)]

		public String StpMaxAge { get; set; }

		

		// STP message age

		[RosValue("stp-msg-age", CanUnset=true)]

		public String StpMsgAge { get; set; }

		

		// STP port identifier

		[RosValue("stp-port", CanUnset=true)]

		public String StpPort { get; set; }

		

		// Root bridge MAC address

		[RosValue("stp-root-address", CanUnset=true)]

		public String StpRootAddress { get; set; }

		

		// Root bridge cost

		[RosValue("stp-root-cost", CanUnset=true)]

		public String StpRootCost { get; set; }

		

		// Root bridge priority

		[RosValue("stp-root-priority", CanUnset=true)]

		public String StpRootPriority { get; set; }

		

		// STP message sender MAC address

		[RosValue("stp-sender-address", CanUnset=true)]

		public String StpSenderAddress { get; set; }

		

		// Sender priority

		[RosValue("stp-sender-priority", CanUnset=true)]

		public String StpSenderPriority { get; set; }

		

		// Bridge Protocol Data Unit (BPDU) type

		[RosValue("stp-type", CanUnset=true)]

		public String StpType { get; set; }

		

		// The encapsulated Ethernet type

		[RosValue("vlan-encap", CanUnset=true)]

		public String VlanEncap { get; set; }

		

		// VLAN identifier field

		[RosValue("vlan-id", CanUnset=true)]

		public String VlanId { get; set; }

		

		// The user priority field

		[RosValue("vlan-priority", CanUnset=true)]

		public String VlanPriority { get; set; }

		

		[RosValue("dynamic", IsDynamic=true)]

		public String Dynamic { get; set; }

		

		[RosValue("invalid", IsDynamic=true)]

		public String Invalid { get; set; }

		

		[RosValue("bytes", IsDynamic=true)]

		public Int64? Bytes { get; set; }

		

		[RosValue("packets", IsDynamic=true)]

		public Int64? Packets { get; set; }

		

	}

	[RosObject("interface bridge filter", CanAdd=true, CanSet=true, CanMove=true, CanGet=true, CanRemove=true, CanUnset=true)]

	public class InterfaceBridgeFilter : RosItemObject<InterfaceBridgeFilter>

	{

		public enum ActionEnum

		{

			[RosValue("accept")]

			Accept,

			[RosValue("drop")]

			Drop,

			[RosValue("jump")]

			Jump,

			[RosValue("log")]

			Log,

			[RosValue("mark-packet")]

			MarkPacket,

		}

		

		// Action to undertake if the packet matches the rule

		[RosValue("action")]

		public ActionEnum? Action { get; set; }

		

		// ARP destination address

		[RosValue("arp-dst-address", CanUnset=true)]

		public String ArpDstAddress { get; set; }

		

		// ARP destination MAC address

		[RosValue("arp-dst-mac-address", CanUnset=true)]

		public String ArpDstMacAddress { get; set; }

		

		[RosValue("arp-gratuitous", CanUnset=true)]

		public Boolean? ArpGratuitous { get; set; }

		

		// The hardware type

		[RosValue("arp-hardware-type", CanUnset=true)]

		public String ArpHardwareType { get; set; }

		

		// The ARP opcode

		[RosValue("arp-opcode", CanUnset=true)]

		public String ArpOpcode { get; set; }

		

		// ARP packet type

		[RosValue("arp-packet-type", CanUnset=true)]

		public String ArpPacketType { get; set; }

		

		// ARP source address

		[RosValue("arp-src-address", CanUnset=true)]

		public String ArpSrcAddress { get; set; }

		

		// ARP source MAC address

		[RosValue("arp-src-mac-address", CanUnset=true)]

		public String ArpSrcMacAddress { get; set; }

		

		public enum ChainEnum

		{

			[RosValue("forward")]

			Forward,

			[RosValue("input")]

			Input,

			[RosValue("output")]

			Output,

		}

		

		// Chain name

		[RosValue("chain")]

		public ChainEnum? Chain { get; set; }

		

		// Short description of the item

		[RosValue("comment")]

		public String Comment { get; set; }

		

		// Defines whether item is ignored or used

		[RosValue("disabled")]

		public Boolean? Disabled { get; set; }

		

		// Destination address

		[RosValue("dst-address", CanUnset=true)]

		public String DstAddress { get; set; }

		

		// Destination MAC address

		[RosValue("dst-mac-address", CanUnset=true)]

		public String DstMacAddress { get; set; }

		

		// Destination port

		[RosValue("dst-port", CanUnset=true)]

		public String DstPort { get; set; }

		

		// Bridge interface the packet is coming in

		[RosValue("in-bridge", CanUnset=true)]

		public String InBridge { get; set; }

		

		// Interface name packets are coming into the bridge

		[RosValue("in-interface", CanUnset=true)]

		public String InInterface { get; set; }

		

		[RosValue("ingress-priority", CanUnset=true)]

		public String IngressPriority { get; set; }

		

		// IP protocol name

		[RosValue("ip-protocol", CanUnset=true)]

		public String IpProtocol { get; set; }

		

		public enum JumpTargetEnum

		{

			[RosValue("forward")]

			Forward,

			[RosValue("input")]

			Input,

			[RosValue("output")]

			Output,

		}

		

		// if action=jump, then jump destination should be set here

		[RosValue("jump-target")]

		public JumpTargetEnum? JumpTarget { get; set; }

		

		// Restricts packet match rate to a given limit

		[RosValue("limit", CanUnset=true)]

		public String Limit { get; set; }

		

		// Defines the prefix to be printed before the logging information

		[RosValue("log-prefix")]

		public String LogPrefix { get; set; }

		

		// Protocol name  or number

		[RosValue("mac-protocol", CanUnset=true)]

		public String MacProtocol { get; set; }

		

		[RosValue("new-packet-mark")]

		public String NewPacketMark { get; set; }

		

		public enum NewPriorityEnum

		{

			[RosValue("from-ingress")]

			FromIngress,

		}

		

		public struct NewPriorityType 

                { 

                    private object value; 

                    public Int32? Num 

                { 

                    get { return value as Int32?; } 

                    set { this.value = value; } 

                } 

                public static implicit operator NewPriorityType(Int32? value) 

                { 

                    return new NewPriorityType() { value = value }; 

                }public NewPriorityEnum? State 

                { 

                    get { return value as NewPriorityEnum?; } 

                    set { this.value = value; } 

                } 

                public static implicit operator NewPriorityType(NewPriorityEnum? value) 

                { 

                    return new NewPriorityType() { value = value }; 

                } 

                    public static NewPriorityType Parse(string str, Connection conn)

                    {

                        

                try { return new NewPriorityType() { value = TypeFormatter.ConvertFromString<Int32>(str, conn) }; }

                catch(Exception) { }

                try { return new NewPriorityType() { value = TypeFormatter.ConvertFromString<NewPriorityEnum>(str, conn) }; }

                catch(Exception) { }

                        throw new NotSupportedException();

                    }

                    public override string ToString() { return value != null ? value.ToString() : null; } 

                }

		[RosValue("new-priority")]

		public NewPriorityType? NewPriority { get; set; }

		

		// Bridge interface the packet is going out

		[RosValue("out-bridge", CanUnset=true)]

		public String OutBridge { get; set; }

		

		// Interface name packets are leaving the bridge

		[RosValue("out-interface", CanUnset=true)]

		public String OutInterface { get; set; }

		

		[RosValue("packet-mark", CanUnset=true)]

		public String PacketMark { get; set; }

		

		// Packet type

		[RosValue("packet-type", CanUnset=true)]

		public String PacketType { get; set; }

		

		[RosValue("passthrough")]

		public Boolean? Passthrough { get; set; }

		

		// Source address

		[RosValue("src-address", CanUnset=true)]

		public String SrcAddress { get; set; }

		

		// Source MAC address

		[RosValue("src-mac-address", CanUnset=true)]

		public String SrcMacAddress { get; set; }

		

		// Source port

		[RosValue("src-port", CanUnset=true)]

		public String SrcPort { get; set; }

		

		// BPDU flags

		[RosValue("stp-flags", CanUnset=true)]

		public String StpFlags { get; set; }

		

		// Forward delay timer

		[RosValue("stp-forward-delay", CanUnset=true)]

		public String StpForwardDelay { get; set; }

		

		// STP hello packets time

		[RosValue("stp-hello-time", CanUnset=true)]

		public String StpHelloTime { get; set; }

		

		// STP maximum age

		[RosValue("stp-max-age", CanUnset=true)]

		public String StpMaxAge { get; set; }

		

		// STP message age

		[RosValue("stp-msg-age", CanUnset=true)]

		public String StpMsgAge { get; set; }

		

		// STP port identifier

		[RosValue("stp-port", CanUnset=true)]

		public String StpPort { get; set; }

		

		// Root bridge MAC address

		[RosValue("stp-root-address", CanUnset=true)]

		public String StpRootAddress { get; set; }

		

		// Root bridge cost

		[RosValue("stp-root-cost", CanUnset=true)]

		public String StpRootCost { get; set; }

		

		// Root bridge priority

		[RosValue("stp-root-priority", CanUnset=true)]

		public String StpRootPriority { get; set; }

		

		// STP message sender MAC address

		[RosValue("stp-sender-address", CanUnset=true)]

		public String StpSenderAddress { get; set; }

		

		// Sender priority

		[RosValue("stp-sender-priority", CanUnset=true)]

		public String StpSenderPriority { get; set; }

		

		// Bridge Protocol Data Unit (BPDU) type

		[RosValue("stp-type", CanUnset=true)]

		public String StpType { get; set; }

		

		// The encapsulated Ethernet type

		[RosValue("vlan-encap", CanUnset=true)]

		public String VlanEncap { get; set; }

		

		// VLAN identifier field

		[RosValue("vlan-id", CanUnset=true)]

		public String VlanId { get; set; }

		

		// The user priority field

		[RosValue("vlan-priority", CanUnset=true)]

		public String VlanPriority { get; set; }

		

		[RosValue("dynamic", IsDynamic=true)]

		public String Dynamic { get; set; }

		

		[RosValue("invalid", IsDynamic=true)]

		public String Invalid { get; set; }

		

		[RosValue("packets", IsDynamic=true)]

		public Int64? Packets { get; set; }

		

		[RosValue("bytes", IsDynamic=true)]

		public Int64? Bytes { get; set; }

		

	}

	[RosObject("interface bridge host", CanGet=true)]

	public class InterfaceBridgeHost : RosItemObject<InterfaceBridgeHost>

	{

		[RosValue("age", IsDynamic=true)]

		public TimeSpan? Age { get; set; }

		

		[RosValue("bridge", IsDynamic=true)]

		public RouterOS.Interface Bridge { get; set; }

		

		[RosValue("external-fdb", IsDynamic=true)]

		public String ExternalFdb { get; set; }

		

		[RosValue("local", IsDynamic=true)]

		public String Local { get; set; }

		

		[RosValue("mac-address", IsDynamic=true)]

		public MACAddress? MacAddress { get; set; }

		

		[RosValue("on-interface", IsDynamic=true)]

		public RouterOS.Interface OnInterface { get; set; }

		

	}

	[RosObject("interface bridge nat", CanAdd=true, CanSet=true, CanMove=true, CanGet=true, CanRemove=true, CanUnset=true)]

	public class InterfaceBridgeNat : RosItemObject<InterfaceBridgeNat>

	{

		public enum ActionEnum

		{

			[RosValue("accept")]

			Accept,

			[RosValue("arp-reply")]

			ArpReply,

			[RosValue("drop")]

			Drop,

			[RosValue("dst-nat")]

			DstNat,

			[RosValue("jump")]

			Jump,

		}

		

		// Action to undertake if the packet matches the rule

		[RosValue("action")]

		public ActionEnum? Action { get; set; }

		

		// ARP destination address

		[RosValue("arp-dst-address", CanUnset=true)]

		public String ArpDstAddress { get; set; }

		

		// ARP destination MAC address

		[RosValue("arp-dst-mac-address", CanUnset=true)]

		public String ArpDstMacAddress { get; set; }

		

		[RosValue("arp-gratuitous", CanUnset=true)]

		public Boolean? ArpGratuitous { get; set; }

		

		// The hardware type

		[RosValue("arp-hardware-type", CanUnset=true)]

		public String ArpHardwareType { get; set; }

		

		// The ARP opcode

		[RosValue("arp-opcode", CanUnset=true)]

		public String ArpOpcode { get; set; }

		

		// ARP packet type

		[RosValue("arp-packet-type", CanUnset=true)]

		public String ArpPacketType { get; set; }

		

		// ARP source address

		[RosValue("arp-src-address", CanUnset=true)]

		public String ArpSrcAddress { get; set; }

		

		// ARP source MAC address

		[RosValue("arp-src-mac-address", CanUnset=true)]

		public String ArpSrcMacAddress { get; set; }

		

		public enum ChainEnum

		{

			[RosValue("dstnat")]

			Dstnat,

			[RosValue("srcnat")]

			Srcnat,

		}

		

		// Chain name

		[RosValue("chain")]

		public ChainEnum? Chain { get; set; }

		

		// Short description of the item

		[RosValue("comment")]

		public String Comment { get; set; }

		

		// Defines whether item is ignored or used

		[RosValue("disabled")]

		public Boolean? Disabled { get; set; }

		

		// Destination address

		[RosValue("dst-address", CanUnset=true)]

		public String DstAddress { get; set; }

		

		// Destination MAC address

		[RosValue("dst-mac-address", CanUnset=true)]

		public String DstMacAddress { get; set; }

		

		// Destination port

		[RosValue("dst-port", CanUnset=true)]

		public String DstPort { get; set; }

		

		// Bridge interface the packet is coming in

		[RosValue("in-bridge", CanUnset=true)]

		public String InBridge { get; set; }

		

		// Interface name packets are coming into the bridge

		[RosValue("in-interface", CanUnset=true)]

		public String InInterface { get; set; }

		

		[RosValue("ingress-priority", CanUnset=true)]

		public String IngressPriority { get; set; }

		

		// IP protocol name

		[RosValue("ip-protocol", CanUnset=true)]

		public String IpProtocol { get; set; }

		

		public enum JumpTargetEnum

		{

			[RosValue("dstnat")]

			Dstnat,

			[RosValue("srcnat")]

			Srcnat,

		}

		

		// if action=jump, then jump destination should be set here

		[RosValue("jump-target")]

		public JumpTargetEnum? JumpTarget { get; set; }

		

		// Restricts packet match rate to a given limit

		[RosValue("limit", CanUnset=true)]

		public String Limit { get; set; }

		

		// Defines the prefix to be printed before the logging information

		[RosValue("log-prefix")]

		public String LogPrefix { get; set; }

		

		// Protocol name  or number

		[RosValue("mac-protocol", CanUnset=true)]

		public String MacProtocol { get; set; }

		

		[RosValue("new-packet-mark")]

		public String NewPacketMark { get; set; }

		

		public enum NewPriorityEnum

		{

			[RosValue("from-ingress")]

			FromIngress,

		}

		

		[RosValue("new-priority")]

		public NewPriorityEnum? NewPriority { get; set; }

		

		// Bridge interface the packet is going out

		[RosValue("out-bridge", CanUnset=true)]

		public String OutBridge { get; set; }

		

		// Interface name packets are leaving the bridge

		[RosValue("out-interface", CanUnset=true)]

		public String OutInterface { get; set; }

		

		[RosValue("packet-mark", CanUnset=true)]

		public String PacketMark { get; set; }

		

		// Packet type

		[RosValue("packet-type", CanUnset=true)]

		public String PacketType { get; set; }

		

		[RosValue("passthrough")]

		public Boolean? Passthrough { get; set; }

		

		// Source address

		[RosValue("src-address", CanUnset=true)]

		public String SrcAddress { get; set; }

		

		// Source MAC address

		[RosValue("src-mac-address", CanUnset=true)]

		public String SrcMacAddress { get; set; }

		

		// Source port

		[RosValue("src-port", CanUnset=true)]

		public String SrcPort { get; set; }

		

		// BPDU flags

		[RosValue("stp-flags", CanUnset=true)]

		public String StpFlags { get; set; }

		

		// Forward delay timer

		[RosValue("stp-forward-delay", CanUnset=true)]

		public String StpForwardDelay { get; set; }

		

		// STP hello packets time

		[RosValue("stp-hello-time", CanUnset=true)]

		public String StpHelloTime { get; set; }

		

		// STP maximum age

		[RosValue("stp-max-age", CanUnset=true)]

		public String StpMaxAge { get; set; }

		

		// STP message age

		[RosValue("stp-msg-age", CanUnset=true)]

		public String StpMsgAge { get; set; }

		

		// STP port identifier

		[RosValue("stp-port", CanUnset=true)]

		public String StpPort { get; set; }

		

		// Root bridge MAC address

		[RosValue("stp-root-address", CanUnset=true)]

		public String StpRootAddress { get; set; }

		

		// Root bridge cost

		[RosValue("stp-root-cost", CanUnset=true)]

		public String StpRootCost { get; set; }

		

		// Root bridge priority

		[RosValue("stp-root-priority", CanUnset=true)]

		public String StpRootPriority { get; set; }

		

		// STP message sender MAC address

		[RosValue("stp-sender-address", CanUnset=true)]

		public String StpSenderAddress { get; set; }

		

		// Sender priority

		[RosValue("stp-sender-priority", CanUnset=true)]

		public String StpSenderPriority { get; set; }

		

		// Bridge Protocol Data Unit (BPDU) type

		[RosValue("stp-type", CanUnset=true)]

		public String StpType { get; set; }

		

		// Source MAC address to put in Ethernet frame and ARP payload, when action=arp-reply is selected

		[RosValue("to-arp-reply-mac-address")]

		public MACAddress? ToArpReplyMacAddress { get; set; }

		

		// Destination MAC address to put in Ethernet frames, when action=dst-nat is selected

		[RosValue("to-dst-mac-address")]

		public MACAddress? ToDstMacAddress { get; set; }

		

		// Source MAC address to put in Ethernet frames, when action=src-nat is selected

		[RosValue("to-src-mac-address")]

		public MACAddress? ToSrcMacAddress { get; set; }

		

		// The encapsulated Ethernet type

		[RosValue("vlan-encap", CanUnset=true)]

		public String VlanEncap { get; set; }

		

		// VLAN identifier field

		[RosValue("vlan-id", CanUnset=true)]

		public String VlanId { get; set; }

		

		// The user priority field

		[RosValue("vlan-priority", CanUnset=true)]

		public String VlanPriority { get; set; }

		

		[RosValue("dynamic", IsDynamic=true)]

		public String Dynamic { get; set; }

		

		[RosValue("invalid", IsDynamic=true)]

		public String Invalid { get; set; }

		

		[RosValue("packets", IsDynamic=true)]

		public Int64? Packets { get; set; }

		

		[RosValue("bytes", IsDynamic=true)]

		public Int64? Bytes { get; set; }

		

	}

	[RosObject("interface bridge port", CanAdd=true, CanSet=true, CanGet=true, CanRemove=true)]

	public class InterfaceBridgePort : RosItemObject<InterfaceBridgePort>

	{

		// The bridge interface the respective interface is grouped in

		[RosValue("bridge")]

		public RouterOS.Interface Bridge { get; set; }

		

		// Short description of the item

		[RosValue("comment")]

		public String Comment { get; set; }

		

		// Defines whether item is ignored or used

		[RosValue("disabled")]

		public Boolean? Disabled { get; set; }

		

		public enum EdgeEnum

		{

			[RosValue("auto")]

			Auto,

			[RosValue("no")]

			No,

			[RosValue("no-discover")]

			NoDiscover,

			[RosValue("yes")]

			Yes,

			[RosValue("yes-discover")]

			YesDiscover,

		}

		

		[RosValue("edge")]

		public EdgeEnum? Edge { get; set; }

		

		public enum ExternalFdbEnum

		{

			[RosValue("auto")]

			Auto,

			[RosValue("no")]

			No,

			[RosValue("yes")]

			Yes,

		}

		

		[RosValue("external-fdb")]

		public ExternalFdbEnum? ExternalFdb { get; set; }

		

		public enum HorizonEnum

		{

			[RosValue("none")]

			None,

		}

		

		public struct HorizonType 

                { 

                    private object value; 

                    public Int32? Num 

                { 

                    get { return value as Int32?; } 

                    set { this.value = value; } 

                } 

                public static implicit operator HorizonType(Int32? value) 

                { 

                    return new HorizonType() { value = value }; 

                }public HorizonEnum? State 

                { 

                    get { return value as HorizonEnum?; } 

                    set { this.value = value; } 

                } 

                public static implicit operator HorizonType(HorizonEnum? value) 

                { 

                    return new HorizonType() { value = value }; 

                } 

                    public static HorizonType Parse(string str, Connection conn)

                    {

                        

                try { return new HorizonType() { value = TypeFormatter.ConvertFromString<Int32>(str, conn) }; }

                catch(Exception) { }

                try { return new HorizonType() { value = TypeFormatter.ConvertFromString<HorizonEnum>(str, conn) }; }

                catch(Exception) { }

                        throw new NotSupportedException();

                    }

                    public override string ToString() { return value != null ? value.ToString() : null; } 

                }

		[RosValue("horizon")]

		public HorizonType? Horizon { get; set; }

		

		// Name of the interface

		[RosValue("interface")]

		public RouterOS.Interface Interface { get; set; }

		

		// Path cost to the interface, used by STP to determine the 'best' path

		[RosValue("path-cost")]

		public Int32? PathCost { get; set; }

		

		public enum PointToPointEnum

		{

			[RosValue("auto")]

			Auto,

			[RosValue("no")]

			No,

			[RosValue("yes")]

			Yes,

		}

		

		[RosValue("point-to-point")]

		public PointToPointEnum? PointToPoint { get; set; }

		

		// The priority of the interface in comparison with other going to the same subnet

		[RosValue("priority")]

		public Int32? Priority { get; set; }

		

		[RosValue("debug-info", IsDynamic=true)]

		public String DebugInfo { get; set; }

		

		[RosValue("designated-bridge", IsDynamic=true)]

		public Int32? DesignatedBridge { get; set; }

		

		[RosValue("designated-cost", IsDynamic=true)]

		public Int32? DesignatedCost { get; set; }

		

		[RosValue("designated-port-number", IsDynamic=true)]

		public Int32? DesignatedPortNumber { get; set; }

		

		[RosValue("dynamic", IsDynamic=true)]

		public String Dynamic { get; set; }

		

		[RosValue("edge-port", IsDynamic=true)]

		public String EdgePort { get; set; }

		

		[RosValue("edge-port-discovery", IsDynamic=true)]

		public String EdgePortDiscovery { get; set; }

		

		[RosValue("external-fdb-status", IsDynamic=true)]

		public String ExternalFdbStatus { get; set; }

		

		[RosValue("forwarding", IsDynamic=true)]

		public String Forwarding { get; set; }

		

		[RosValue("inactive", IsDynamic=true)]

		public String Inactive { get; set; }

		

		[RosValue("learning", IsDynamic=true)]

		public String Learning { get; set; }

		

		[RosValue("point-to-point-port", IsDynamic=true)]

		public String PointToPointPort { get; set; }

		

		[RosValue("port-number", IsDynamic=true)]

		public Int32? PortNumber { get; set; }

		

		public enum RoleType

		{

			[RosValue("alternate-port")]

			AlternatePort,

			[RosValue("backup-port")]

			BackupPort,

			[RosValue("designated-port")]

			DesignatedPort,

			[RosValue("disabled-port")]

			DisabledPort,

			[RosValue("root-port")]

			RootPort,

		}

		

		[RosValue("role", IsDynamic=true)]

		public RoleType? Role { get; set; }

		

		[RosValue("root-path-cost", IsDynamic=true)]

		public Int32? RootPathCost { get; set; }

		

		[RosValue("sending-rstp", IsDynamic=true)]

		public String SendingRstp { get; set; }

		

		public enum StatusType

		{

			[RosValue("in-bridge")]

			InBridge,

			[RosValue("inactive")]

			Inactive,

		}

		

		[RosValue("status", IsDynamic=true)]

		public StatusType? Status { get; set; }

		

	}

	[RosObject("interface bridge settings", CanSet=true, CanGet=true)]

	public class InterfaceBridgeSettings : RosValueObject

	{

		[RosValue("use-ip-firewall")]

		public Boolean? UseIpFirewall { get; set; }

		

		[RosValue("use-ip-firewall-for-pppoe")]

		public Boolean? UseIpFirewallForPppoe { get; set; }

		

		[RosValue("use-ip-firewall-for-vlan")]

		public Boolean? UseIpFirewallForVlan { get; set; }

		

	}

	[RosObject("interface eoip", CanAdd=true, CanSet=true, CanGet=true, CanRemove=true, CanUnset=true)]

	public class InterfaceEoip : RosItemObject<InterfaceEoip>

	{

		public enum ArpEnum

		{

			[RosValue("disabled")]

			Disabled,

			[RosValue("enabled")]

			Enabled,

			[RosValue("proxy-arp")]

			ProxyArp,

			[RosValue("reply-only")]

			ReplyOnly,

		}

		

		// Address Resolution Protocol

		[RosValue("arp")]

		public ArpEnum? Arp { get; set; }

		

		// Short description of the item

		[RosValue("comment")]

		public String Comment { get; set; }

		

		// Defines whether item is ignored or used

		[RosValue("disabled")]

		public Boolean? Disabled { get; set; }

		

		[RosValue("keepalive", CanUnset=true)]

		public Int32? Keepalive { get; set; }

		

		[RosValue("l2mtu")]

		public UInt16? L2mtu { get; set; }

		

		// MAC address of the EoIP interface

		[RosValue("mac-address")]

		public MACAddress? MacAddress { get; set; }

		

		// Maximum Transmit Unit

		[RosValue("mtu")]

		public UInt16? Mtu { get; set; }

		

		// Tunnel name

		[RosValue("name")]

		public String Name { get; set; }

		

		// Remote address of tunnel

		[RosValue("remote-address")]

		public IPAddress RemoteAddress { get; set; }

		

		// Tunnel identity

		[RosValue("tunnel-id")]

		public Int32? TunnelId { get; set; }

		

		[RosValue("running", IsDynamic=true)]

		public String Running { get; set; }

		

		public static InterfaceEoip Parse(string str, Connection conn)

		{

			if(string.IsNullOrEmpty(str))

				return null;

			InterfaceEoip obj = new InterfaceEoip();

			obj.FindByName(conn, str);

			return obj;

		}

		

		public override string ToString() { return Name.ToString(); }

		

	}

	[RosObject("interface eoipv6", CanAdd=true, CanSet=true, CanGet=true, CanRemove=true, CanUnset=true)]

	public class InterfaceEoipv6 : RosItemObject<InterfaceEoipv6>

	{

		public enum ArpEnum

		{

			[RosValue("disabled")]

			Disabled,

			[RosValue("enabled")]

			Enabled,

			[RosValue("proxy-arp")]

			ProxyArp,

			[RosValue("reply-only")]

			ReplyOnly,

		}

		

		// Address Resolution Protocol

		[RosValue("arp")]

		public ArpEnum? Arp { get; set; }

		

		// Short description of the item

		[RosValue("comment")]

		public String Comment { get; set; }

		

		// Defines whether item is ignored or used

		[RosValue("disabled")]

		public Boolean? Disabled { get; set; }

		

		[RosValue("keepalive", CanUnset=true)]

		public Int32? Keepalive { get; set; }

		

		[RosValue("l2mtu")]

		public UInt16? L2mtu { get; set; }

		

		[RosValue("local-address")]

		public String LocalAddress { get; set; }

		

		[RosValue("mac-address")]

		public MACAddress? MacAddress { get; set; }

		

		// Maximum Transmit Unit

		[RosValue("mtu")]

		public UInt16? Mtu { get; set; }

		

		// Interface name

		[RosValue("name")]

		public String Name { get; set; }

		

		[RosValue("remote-address")]

		public String RemoteAddress { get; set; }

		

		[RosValue("tunnel-id")]

		public Int32? TunnelId { get; set; }

		

		[RosValue("running", IsDynamic=true)]

		public String Running { get; set; }

		

		public static InterfaceEoipv6 Parse(string str, Connection conn)

		{

			if(string.IsNullOrEmpty(str))

				return null;

			InterfaceEoipv6 obj = new InterfaceEoipv6();

			obj.FindByName(conn, str);

			return obj;

		}

		

		public override string ToString() { return Name.ToString(); }

		

	}

	[RosObject("interface ethernet", CanSet=true, CanGet=true)]

	public class InterfaceEthernet : RosItemObject<InterfaceEthernet>

	{

		public enum ArpEnum

		{

			[RosValue("disabled")]

			Disabled,

			[RosValue("enabled")]

			Enabled,

			[RosValue("proxy-arp")]

			ProxyArp,

			[RosValue("reply-only")]

			ReplyOnly,

		}

		

		// Address Resolution Protocol

		[RosValue("arp")]

		public ArpEnum? Arp { get; set; }

		

		// When enabled the interface "advertises" the maximum capabilities to achieve the best connection possible

		[RosValue("auto-negotiation")]

		public Boolean? AutoNegotiation { get; set; }

		

		public enum CableSettingsEnum

		{

			[RosValue("default")]

			Default,

			[RosValue("short")]

			Short,

			[RosValue("standard")]

			Standard,

		}

		

		// Ethernet cable type

		[RosValue("cable-settings")]

		public CableSettingsEnum? CableSettings { get; set; }

		

		// Short description of the item

		[RosValue("comment")]

		public String Comment { get; set; }

		

		// Disable running check

		[RosValue("disable-running-check")]

		public Boolean? DisableRunningCheck { get; set; }

		

		// Defines whether item is ignored or used

		[RosValue("disabled")]

		public Boolean? Disabled { get; set; }

		

		// Defines whether the transmissionof data appearsin two directions simultaneously

		[RosValue("full-duplex")]

		public Boolean? FullDuplex { get; set; }

		

		[RosValue("l2mtu")]

		public UInt16? L2mtu { get; set; }

		

		// MAC address

		[RosValue("mac-address")]

		public MACAddress? MacAddress { get; set; }

		

		[RosValue("mdix-enable")]

		public Boolean? MdixEnable { get; set; }

		

		// Maximum Transmit Unit

		[RosValue("mtu")]

		public UInt16? Mtu { get; set; }

		

		// Interface name

		[RosValue("name")]

		public String Name { get; set; }

		

		public enum PoeOutEnum

		{

			[RosValue("auto")]

			Auto,

			[RosValue("off")]

			Off,

		}

		

		[RosValue("poe-out")]

		public PoeOutEnum? PoeOut { get; set; }

		

		public enum SpeedEnum

		{

			[RosValue("100Mbps")]

			E100Mbps,

			[RosValue("10Mbps")]

			E10Mbps,

			[RosValue("1Gbps")]

			E1Gbps,

		}

		

		// sets the data transmission speed of the interface

		[RosValue("speed")]

		public SpeedEnum? Speed { get; set; }

		

		[RosValue("driver-rx-byte", IsDynamic=true)]

		public Int64? DriverRxByte { get; set; }

		

		[RosValue("driver-rx-packet", IsDynamic=true)]

		public Int64? DriverRxPacket { get; set; }

		

		[RosValue("driver-tx-byte", IsDynamic=true)]

		public Int64? DriverTxByte { get; set; }

		

		[RosValue("driver-tx-packet", IsDynamic=true)]

		public Int64? DriverTxPacket { get; set; }

		

		[RosValue("running", IsDynamic=true)]

		public String Running { get; set; }

		

		[RosValue("rx-1024-1518", IsDynamic=true)]

		public Int64? Rx10241518 { get; set; }

		

		[RosValue("rx-128-255", IsDynamic=true)]

		public Int64? Rx128255 { get; set; }

		

		[RosValue("rx-1519-max", IsDynamic=true)]

		public Int64? Rx1519Max { get; set; }

		

		[RosValue("rx-256-511", IsDynamic=true)]

		public Int64? Rx256511 { get; set; }

		

		[RosValue("rx-512-1023", IsDynamic=true)]

		public Int64? Rx5121023 { get; set; }

		

		[RosValue("rx-64", IsDynamic=true)]

		public Int64? Rx64 { get; set; }

		

		[RosValue("rx-65-127", IsDynamic=true)]

		public Int64? Rx65127 { get; set; }

		

		[RosValue("rx-align-error", IsDynamic=true)]

		public Int64? RxAlignError { get; set; }

		

		[RosValue("rx-broadcast", IsDynamic=true)]

		public Int64? RxBroadcast { get; set; }

		

		[RosValue("rx-bytes", IsDynamic=true)]

		public Int64? RxBytes { get; set; }

		

		[RosValue("rx-carrier-error", IsDynamic=true)]

		public Int64? RxCarrierError { get; set; }

		

		[RosValue("rx-code-error", IsDynamic=true)]

		public Int64? RxCodeError { get; set; }

		

		[RosValue("rx-control", IsDynamic=true)]

		public Int64? RxControl { get; set; }

		

		[RosValue("rx-drop", IsDynamic=true)]

		public Int64? RxDrop { get; set; }

		

		[RosValue("rx-fcs-error", IsDynamic=true)]

		public Int64? RxFcsError { get; set; }

		

		[RosValue("rx-fragment", IsDynamic=true)]

		public Int64? RxFragment { get; set; }

		

		[RosValue("rx-jabber", IsDynamic=true)]

		public Int64? RxJabber { get; set; }

		

		[RosValue("rx-length-error", IsDynamic=true)]

		public Int64? RxLengthError { get; set; }

		

		[RosValue("rx-multicast", IsDynamic=true)]

		public Int64? RxMulticast { get; set; }

		

		[RosValue("rx-overflow", IsDynamic=true)]

		public Int64? RxOverflow { get; set; }

		

		[RosValue("rx-packet", IsDynamic=true)]

		pub…