path: root/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Router 2600/cmd_intBri.txt

intBriC.addSC("access-expression", "Build a bridge boolean access expression");

intBriC.addSC("arp", "Set arp type (arpa, probe, snap) or timeout");

intBriC.addSC("autodetect", "Autodetect Encapsulations on Serial interface");

intBriC.addSC("bandwidth", "Set bandwidth informational parameter");

   intBriC.bandwidth.addSC("<1-10000000>", "Bandwidth in kilobits");

intBriC.addSC("bridge-group", "Transparent bridging interface parameters");

intBriC.addSC("carrier-delay", "Specify delay for interface transitions");

intBriC.addSC("cdp", "CDP interface subcommands");

   intBriC.cdp.addSC("enable", "Enable CDP on interface");

intBriC.addSC("clock", "Configure serial interface clock");

   intBriC.clock.addSC("rate", "Configure serial interface clock speed");

      intBriC.clock.rate.addSC("<300-4000000>", "Choose clockrate from list above");

intBriC.addSC("compress", "Set serial interface for compression");

   intBriC.compress.addSC("stac", "stac compression algorithm");

intBriC.addSC("cpp", "Combinet Proprietary Protocol");

intBriC.addSC("custom-queue-list", "Assign a custom queue list to an interface");

   intBriC["custom-queue-list"].addSC("<1-16>", "Custom queue list number");

intBriC.addSC("default", "Set a command to its defaults");

intBriC.addSC("delay", "Specify interface throughput delay");

intBriC.addSC("description", "Interface specific description");

   intBriC.description.addSC("LINE", "Up to 240 characters describing this interface");

intBriC.addSC("dialer", "Dial-on-demand routing (DDR) commands");

   intBriC.dialer.addSC("callback-secure", "Enable callback security");

   intBriC.dialer.addSC("enable-timeout", "Set length of time an interface stays down before it is available for dialing");

      intBriC.dialer["enable-timeout"].addSC("<1-2147483>", "Enable timeout in seconds");

   intBriC.dialer.addSC("fast-idle", "Set idle time before disconnecting line with an unusually high level of contention");

      intBriC.dialer["fast-idle"].addSC("<1-2147483>", "Fast idle in seconds");

   intBriC.dialer.addSC("hold-queue", "Configure output hold queue");

      intBriC.dialer["hold-queue"].addSC("<0-100>", "Specify size of output hold queue");

         intBriC.dialer["hold-queue"]["<0-100>"].addSC("timeout", "Specify length of time data is held while interface is connecting");

            intBriC.dialer["hold-queue"]["<0-100>"].timeout.addSC("<1-2147483>", "Holdq timeout in seconds is this value + enable time");

   intBriC.dialer.addSC("idle-timeout", "Specify idle timeout before disconnecting line");

      intBriC.dialer["idle-timeout"].addSC("<0-2147483>", "Idle timeout before disconnecting a call");

         intBriC.dialer["idle-timeout"]["<0-2147483>"].addSC("either", "Reset idle timer based on both inbound and outbound traffic");

         intBriC.dialer["idle-timeout"]["<0-2147483>"].addSC("inbound", "Reset idle timer based on inbound traffic only");

   intBriC.dialer.addSC("load-threshold", "Specify threshold for placing additional calls");

      intBriC.dialer["load-threshold"].addSC("<1-255>", "Load threshold to place another call");

         intBriC.dialer["load-threshold"]["<1-255>"].addSC("either", "Threshold decision based on max of inbound and outbound traffic");

         intBriC.dialer["load-threshold"]["<1-255>"].addSC("inbound", "Threshold decision based on inbound traffic only");

         intBriC.dialer["load-threshold"]["<1-255>"].addSC("outbound", "Threshold decision based on outbound traffic only");

   intBriC.dialer.addSC("map", "Define multiple dial-on-demand numbers");

      intBriC.dialer.map.addSC("bridge", "Bridging");

         intBriC.dialer.map.bridge.addSC("speed", "Set dialer speed");

intBriC.addSC("dialer-group", "Assign interface to dialer-list");

   intBriC["dialer-group"].addSC("<1-10>", "Dialer list number");

intBriC.addSC("down-when-looped", "Force looped serial interface down");

intBriC.addSC("dxi", "ATM-DXI configuration commands");

intBriC.addSC("encapsulation", "Set encapsulation type for an interface");

   intBriC.encapsulation.addSC("cpp", "Combinet proprietary protocol");

   intBriC.encapsulation.addSC("frame-relay", "Frame Relay networks");

      intBriC.encapsulation["frame-relay"].addSC("ietf", "Use RFC1490/RFC2427 encapsulation");

   intBriC.encapsulation.addSC("hdlc", "Serial HDLC synchronous");

   intBriC.encapsulation.addSC("lapb", "LAPB (X.25 Level 2)");

      intBriC.encapsulation.lapb.addSC("dce", "DCE operation");

      intBriC.encapsulation.lapb.addSC("dte", "DTE operation");

      intBriC.encapsulation.lapb.addSC("ip", "IP");

      intBriC.encapsulation.lapb.addSC("multi", "Multiprotocol operation");

      intBriC.encapsulation.lapb.addSC("snapshot", "Snapshot routing support");

   intBriC.encapsulation.addSC("ppp", "Point-to-Point protocol");

   intBriC.encapsulation.addSC("x25", "X.25");

      intBriC.encapsulation.x25.addSC("dce", "DCE operation");

      intBriC.encapsulation.x25.addSC("dte", "DTE operation");

      intBriC.encapsulation.x25.addSC("ietf", "Default to IETF's RFC-1356 encapsulation");

      intBriC.encapsulation.x25.addSC("profile", "Use a defined X.25 profile configuration");

         intBriC.encapsulation.x25.profile.addSC("WORD", "Name of the profile");

            intBriC.encapsulation.x25.profile.WORD.addSC("ax25", "Default to IATA's Airline X.25");

            intBriC.encapsulation.x25.profile.WORD.addSC("bfe", "Blacker Front End attachment");

            intBriC.encapsulation.x25.profile.WORD.addSC("ddn", "Defense Data Network attachment");

            intBriC.encapsulation.x25.profile.WORD.addSC("ietf", "Default to IETF's RFC-1356 encapsulation");

intBriC.addSC("exit", "Exit from interface configuration mode");

intBriC.addSC("fair-queue", "Enable Fair Queuing on an Interface");

   intBriC["fair-queue"].addSC("<1-4096>", "Congestive Discard Threshold");

      intBriC["fair-queue"]["<1-4096>"].addSC("<16-4096>", "Number Dynamic Conversation Queues");

         intBriC["fair-queue"]["<1-4096>"]["<16-4096>"].addSC("<0-1000>", "Number Reservable Conversation Queues");

intBriC.addSC("full-duplex", "Configure full-duplex operational mode");

intBriC.addSC("half-duplex", "Configure half-duplex and related commands");

intBriC.addSC("help", "Description of the interactive help system");

intBriC.addSC("hold-queue", "Set hold queue depth");

intBriC.addSC("ip", "Interface Internet Protocol config commands");

   intBriC.ip.addSC("access-group", "Specify access control for packets");

      intBriC.ip["access-group"].addSC("<1-199>", "IP access list (standard or extended)");

         intBriC.ip["access-group"]["<1-199>"].addSC("in", "inbound packets");

         intBriC.ip["access-group"]["<1-199>"].addSC("out", "outbound packets");

      intBriC.ip["access-group"].addSC("<1300-2699>", "IP expanded access list (standard or extended)");

         intBriC.ip["access-group"]["<1300-2699>"].addSC("in", "inbound packets");

         intBriC.ip["access-group"]["<1300-2699>"].addSC("out", "outbound packets");

      intBriC.ip["access-group"].addSC("WORD", "Access-list name");

         intBriC.ip["access-group"].WORD.addSC("in", "inbound packets");

         intBriC.ip["access-group"].WORD.addSC("out", "outbound packets");

   intBriC.ip.addSC("accounting", "Enable IP accounting on this interface");

      intBriC.ip.accounting.addSC("access-violations", "Account for IP packets violating access lists on this interface");

      intBriC.ip.accounting.addSC("output-packets", "Account for IP packets output on this interface");

      intBriC.ip.accounting.addSC("precedence", "Count packets by IP precedence on this interface");

         intBriC.ip.accounting.precedence.addSC("input", "received packets");

         intBriC.ip.accounting.precedence.addSC("output", "transmitted packets");

   intBriC.ip.addSC("address", "Set the IP address of an interface");

      intBriC.ip.address.addSC("A.B.C.D", "IP address");

         intBriC.ip.address["A.B.C.D"].addSC("A.B.C.D", "IP subnet mask");

            intBriC.ip.address["A.B.C.D"]["A.B.C.D"].addSC("secondary", "Make this IP address a secondary address");

      intBriC.ip.address.addSC("negotiated", "IP Address negotiated over PPP");

         intBriC.ip.address.negotiated.addSC("previous", "IPCP attempts to negotiate previous address assigned");

   intBriC.ip.addSC("authentication", "authentication subcommands");

      intBriC.ip.authentication.addSC("key-chain", "key-chain");

         intBriC.ip.authentication["key-chain"].addSC("eigrp", "Enhanced Interior Gateway Routing Protocol (EIGRP)");

            intBriC.ip.authentication["key-chain"].eigrp.addSC("<1-65535>", "Autonomous system number");

               intBriC.ip.authentication["key-chain"].eigrp["<1-65535>"].addSC("WORD", "name of key-chain");

      intBriC.ip.authentication.addSC("mode", "mode");

         intBriC.ip.authentication.mode.addSC("eigrp", "Enhanced Interior Gateway Routing Protocol (EIGRP)");

            intBriC.ip.authentication.mode.eigrp.addSC("<1-65535>", "Autonomous system number");

               intBriC.ip.authentication.mode.eigrp["<1-65535>"].addSC("md5", "Keyed message digest");

   intBriC.ip.addSC("bandwidth-percent", "Set EIGRP bandwidth limit");

      intBriC.ip["bandwidth-percent"].addSC("eigrp", "Enhanced Interior Gateway Routing Protocol (EIGRP)");

         intBriC.ip["bandwidth-percent"].eigrp.addSC("<1-65535>", "Autonomous system number");

            intBriC.ip["bandwidth-percent"].eigrp["<1-65535>"].addSC("<1-999999>", "Maximum bandwidth percentage that EIGRP may use");

   intBriC.ip.addSC("bgp", "BGP interface commands");

      intBriC.ip.bgp.addSC("fast-external-fallover", "Over-ride bgp global fast-failover whenexternal peer goes down");

         intBriC.ip.bgp["fast-external-fallover"].addSC("deny", "dis-allow fast fallover");

         intBriC.ip.bgp["fast-external-fallover"].addSC("permit", "allow fast fallover");

   intBriC.ip.addSC("broadcast-address", "Set the broadcast address of an interface");

      intBriC.ip["broadcast-address"].addSC("A.B.C.D", "IP broadcast address");

   intBriC.ip.addSC("cef", "Cisco Express Fowarding interface commands");

      intBriC.ip.cef.addSC("accounting", "CEF accounting features for interface");

         intBriC.ip.cef.accounting.addSC("non-recursive", "CEF non-recursive accounting features");

            intBriC.ip.cef.accounting["non-recursive"].addSC("external", "Count input traffic in non-recursive external bin");

            intBriC.ip.cef.accounting["non-recursive"].addSC("internal", "Count input traffic in non-recursive internal bin");

   intBriC.ip.addSC("cgmp", "Enable/disable CGMP");

      intBriC.ip.cgmp.addSC("proxy", "CGMP for hosts and proxy for multicast routers");

      intBriC.ip.cgmp.addSC("router-only", "CGMP proxy for multicast routers only");

   intBriC.ip.addSC("dhcp", "Configure DHCP parameters for this interface");

      intBriC.ip.dhcp.addSC("relay", "DHCP relay configuration parameters");

         intBriC.ip.dhcp.relay.addSC("information", "DHCP relay information option");

            intBriC.ip.dhcp.relay.information.addSC("trusted", "Received DHCP packet may contain relay info option with zero giaddr");

   intBriC.ip.addSC("directed-broadcast", "Enable forwarding of directed broadcasts");

      intBriC.ip["directed-broadcast"].addSC("<1-199>", "A standard IP access list number");

      intBriC.ip["directed-broadcast"].addSC("<1300-2699>", "A standard IP expanded access list number");

   intBriC.ip.addSC("dvmrp", "DVMRP interface commands");

   intBriC.ip.addSC("load-sharing", "Style of load sharing");

   intBriC.ip.addSC("mask-reply", "Enable sending ICMP Mask Reply messages");

   intBriC.ip.addSC("mrm", "Configure IP Multicast Routing Monitor tester");

   intBriC.ip.addSC("mroute-cache", "Enable switching cache for incoming multicast packets");

   intBriC.ip.addSC("mtu", "Set IP Maximum Transmission Unit");

   intBriC.ip.addSC("multicast", "IP multicast interface commands");

      intBriC.ip.multicast.addSC("boundary", "Boundary for administratively scoped multicast addresses");

         intBriC.ip.multicast.boundary.addSC("<1-99>", "Access-list number");

         intBriC.ip.multicast.boundary.addSC("<1300-1999>", "<access-list> (expanded range)");

         intBriC.ip.multicast.boundary.addSC("WORD", "IP Named Standard Access list");

      intBriC.ip.multicast.addSC("helper-map", "Broadcast to Multicast map OR Multicast to Broadcast map");

      intBriC.ip.multicast.addSC("rate-limit", "Rate limit multicast data packets");

   intBriC.ip.addSC("nat", "NAT interface commands");

   intBriC.ip.addSC("pim", "PIM interface commands");

   intBriC.ip.addSC("rip", "Router Information Protocol");

      intBriC.ip.rip.addSC("authentication", "Authentication control");

         intBriC.ip.rip.authentication.addSC("key-chain", "Authentication key-chain");

            intBriC.ip.rip.authentication["key-chain"].addSC("LINE", "name of key-chain");

         intBriC.ip.rip.authentication.addSC("mode", "Authentication mode");

            intBriC.ip.rip.authentication.mode.addSC("md5", "Keyed message digest");

            intBriC.ip.rip.authentication.mode.addSC("text", "Clear text authentication");

      intBriC.ip.rip.addSC("receive", "advertisement reception");

         intBriC.ip.rip.receive.addSC("version", "version control");

            intBriC.ip.rip.receive.version.addSC("<1-1>", "RIP version 1");

            intBriC.ip.rip.receive.version.addSC("<2-2>", "RIP version 2");

               intBriC.ip.rip.receive.version["<2-2>"].addSC("<1-1>", "RIP version 1");

      intBriC.ip.rip.addSC("send", "advertisement transmission");

         intBriC.ip.rip.send.addSC("version", "version control");

            intBriC.ip.rip.send.version.addSC("<1-1>", "RIP version 1");

            intBriC.ip.rip.send.version.addSC("<2-2>", "RIP version 2");

               intBriC.ip.rip.send.version["<2-2>"].addSC("<1-1>", "RIP version 1");

      intBriC.ip.rip.addSC("triggered", "enable rfc2091 triggered rip");

      intBriC.ip.rip.addSC("v2-broadcast", "send ip broadcast v2 update");

   intBriC.ip.addSC("route-cache", "Enable fast-switching cache for outgoing packets");

      intBriC.ip["route-cache"].addSC("cef", "Enable Cisco Express Forwarding");

      intBriC.ip["route-cache"].addSC("flow", "Enable Flow fast-switching cache");

      intBriC.ip["route-cache"].addSC("policy", "Enable fast-switching policy cache for outgoing packets");

      intBriC.ip["route-cache"].addSC("same-interface", "Enable fast-switching on the same interface");

   intBriC.ip.addSC("rsvp", "RSVP interface commands");

   intBriC.ip.addSC("summary-address", "Perform address summarization");

      intBriC.ip["summary-address"].addSC("eigrp", "Enhanced Interior Gateway Routing Protocol (EIGRP)");

         intBriC.ip["summary-address"].eigrp.addSC("<1-65535>", "Autonomous system number");

            intBriC.ip["summary-address"].eigrp["<1-65535>"].addSC("A.B.C.D", "IP address");

               intBriC.ip["summary-address"].eigrp["<1-65535>"]["A.B.C.D"].addSC("A.B.C.D", "IP network mask");

                  intBriC.ip["summary-address"].eigrp["<1-65535>"]["A.B.C.D"]["A.B.C.D"].addSC("<1-255>", "Administrative distance");

      intBriC.ip["summary-address"].addSC("rip", "Routing Information Protocol (RIP)");

         intBriC.ip["summary-address"].rip.addSC("A.B.C.D", "IP address");

            intBriC.ip["summary-address"].rip["A.B.C.D"].addSC("A.B.C.D", "IP network mask");

   intBriC.ip.addSC("tcp", "TCP header compression parameters");

      intBriC.ip.tcp.addSC("compression-connections", "Maximum number of compressed connections");

         intBriC.ip.tcp["compression-connections"].addSC("<3-256>", "Number of connections");

      intBriC.ip.tcp.addSC("header-compression", "Enable TCP header compression");

         intBriC.ip.tcp["header-compression"].addSC("passive", "Compress only for destinations which send compressed headers");

   intBriC.ip.addSC("trigger-authentication", "Enable trigger-authentication");

   intBriC.ip.addSC("unnumbered", "Enable IP processing without an explicit address");

intBriC.addSC("isdn", "ISDN Interface configuration commands");

   intBriC.isdn.addSC("T306", "Specify Timer T306 in milliseconds");

      intBriC.isdn.T306.addSC("<1-400000>", "Timer T306 value in milliseconds");

   intBriC.isdn.addSC("T310", "Specify Timer T310 in milliseconds");

      intBriC.isdn.T310.addSC("<1-400000>", "Timer T310 value in milliseconds");

   intBriC.isdn.addSC("all-incoming-calls-v120", "Answer all incoming calls as V.120");

   intBriC.isdn.addSC("answer1", "Specify Called Party number and subaddress");

      intBriC.isdn.answer1.addSC("WORD", "answer1 Number");

   intBriC.isdn.addSC("answer2", "Specify Called Party number and subaddress");

      intBriC.isdn.answer2.addSC("WORD", "answer2 Number");

   intBriC.isdn.addSC("autodetect", "Enable the automatic spid detection");

   intBriC.isdn.addSC("caller", "Specify incoming telephone number to be verified");

   intBriC.isdn.addSC("map", "Specify E.164 address to numbering plan/type mapping");

      intBriC.isdn.map.addSC("address", "Map an ISDN address");

         intBriC.isdn.map.address.addSC("WORD", "ISDN address to map");

            intBriC.isdn.map.address.WORD.addSC("plan", "Set address numbering plan");

               intBriC.isdn.map.address.WORD.plan.addSC("data", "Data plan");



intBriC.addSC("keepalive", "Enable keepalive");

   intBriC.keepalive.addSC("<0-32767>", "Keepalive period (default 10 seconds)");

intBriC.addSC("line-power", "Provide power on the line.");

intBriC.addSC("llc2", "LLC2 Interface Subcommands");

intBriC.addSC("load-interval", "Specify interval for load calculation for an interface");

intBriC.addSC("logging", "Configure logging for interface");

intBriC.addSC("mac-address", "Manually set interface MAC address");

intBriC.addSC("max-reserved-bandwidth", "Maximum Reservable Bandwidth on an Interface");

intBriC.addSC("mtu", "Set the interface Maximum Transmission Unit (MTU)");

intBriC.addSC("multilink-group", "Put interface in a multilink bundle");

intBriC.addSC("netbios", "Use a defined NETBIOS access list or enable name-caching");

intBriC.addSC("network-clock-priority", "Configure clock source priority");



intBriC.addSC("no", "Negate a command or set its defaults");

   intBriC.no.addSC("access-expression", "Build a bridge boolean access expression");

      intBriC.no["access-expression"].addSC("input", "Filter input packets");

      intBriC.no["access-expression"].addSC("output", "Filter output packets");

   intBriC.no.addSC("arp", "Set arp type (arpa, probe, snap) or timeout");

      intBriC.no.arp.addSC("arpa", "Standard arp protocol");

      intBriC.no.arp.addSC("frame-relay", "Enable ARP for a frame relay interface");

      intBriC.no.arp.addSC("probe", "HP style arp protocol");

      intBriC.no.arp.addSC("snap", "IEEE 802.3 style arp");

      intBriC.no.arp.addSC("timeout", "Set ARP cache timeout");

   intBriC.no.addSC("autodetect", "Autodetect Encapsulations on Serial interface");

      intBriC.no.autodetect.addSC("encapsulation", "list of allowed encapsulations for autodetect");

   intBriC.no.addSC("bandwidth", "Set bandwidth informational parameter");

   intBriC.no.addSC("bridge-group", "Transparent bridging interface parameters");

      intBriC.no["bridge-group"].addSC("<1-255>", "Assign an interface to a Bridge Group.");

         intBriC.no["bridge-group"]["<1-255>"].addSC("circuit-group", "Associate serial interface with a circuit group");

   intBriC.no.addSC("carrier-delay", "Specify delay for interface transitions");

   intBriC.no.addSC("cdp", "CDP interface subcommands");

      intBriC.no.cdp.addSC("enable", "Enable CDP on interface");

   intBriC.no.addSC("clock", "Configure serial interface clock");

      intBriC.no.clock.addSC("rate", "Configure serial interface clock speed");

   intBriC.no.addSC("compress", "Set serial interface for compression");

   intBriC.no.addSC("cpp", "Combinet Proprietary Protocol");

      intBriC.no.cpp.addSC("authentication", "Set cpp authentication to required");

      intBriC.no.cpp.addSC("callback", "Set CPP link callback option");

         intBriC.no.cpp.callback.addSC("accept", "Accept a callback request");

   intBriC.no.addSC("custom-queue-list", "Assign a custom queue list to an interface");

   intBriC.no.addSC("delay", "Specify interface throughput delay");

   intBriC.no.addSC("description", "Interface specific description");

   intBriC.no.addSC("dialer", "Dial-on-demand routing (DDR) commands");

      intBriC.no.dialer.addSC("callback-secure", "Enable callback security");

   intBriC.no.addSC("dialer-group", "Assign interface to dialer-list");

   intBriC.no.addSC("down-when-looped", "Force looped serial interface down");

   intBriC.no.addSC("dxi", "ATM-DXI configuration commands");

      intBriC.no.dxi.addSC("interface-dfa", "Define a DFA as part of a subinterface");

         intBriC.no.dxi["interface-dfa"].addSC("<0-15>", "VPI");

            intBriC.no.dxi["interface-dfa"]["<0-15>"].addSC("<0-63>", "VCI");

   intBriC.no.addSC("encapsulation", "Set encapsulation type for an interface");

      intBriC.no.encapsulation.addSC("cpp", "Combinet proprietary protocol");

      intBriC.no.encapsulation.addSC("frame-relay", "Frame Relay networks");

         intBriC.no.encapsulation["frame-relay"].addSC("ietf", "Use RFC1490/RFC2427 encapsulation");

      intBriC.no.encapsulation.addSC("hdlc", "Serial HDLC synchronous");

      intBriC.no.encapsulation.addSC("lapb", "LAPB (X.25 Level 2)");

   intBriC.no.addSC("fair-queue", "Enable Fair Queuing on an Interface");

      intBriC.no["fair-queue"].addSC("<1-4096>", "Congestive Discard Threshold");

         intBriC.no["fair-queue"]["<1-4096>"].addSC("<16-4096>", "Number Dynamic Conversation Queues");

            intBriC.no["fair-queue"]["<1-4096>"]["<16-4096>"].addSC("<0-1000>", "Number Reservable Conversation Queues");

   intBriC.no.addSC("full-duplex", "Configure full-duplex operational mode");

   intBriC.no.addSC("half-duplex", "Configure half-duplex and related commands");

      intBriC.no["half-duplex"].addSC("timer", "Half-duplex timer tuning commands");

         intBriC.no["half-duplex"].timer.addSC("cts-delay", "CTS delay value");

         intBriC.no["half-duplex"].timer.addSC("rts-timeout", "RTS timeout value");

   intBriC.no.addSC("hold-queue", "Set hold queue depth");

      intBriC.no["hold-queue"].addSC("<0-4096>", "Queue length");

      intBriC.no["hold-queue"].addSC("in", "Input queue");

      intBriC.no["hold-queue"].addSC("out", "Output queue");

   intBriC.no.addSC("ip", "Interface Internet Protocol config commands");

      intBriC.no.ip.addSC("access-group", "Specify access control for packets");

         intBriC.no.ip["access-group"].addSC("<1-199>", "IP access list (standard or extended)");

      intBriC.no.ip.addSC("accounting", "Enable IP accounting on this interface");

         intBriC.no.ip.accounting.addSC("access-violations", "Account for IP packets violating access lists on this interface");

         intBriC.no.ip.accounting.addSC("output-packets", "Account for IP packets output on this interface");

         intBriC.no.ip.accounting.addSC("precedence", "Count packets by IP precedence on this interface");

            intBriC.no.ip.accounting.precedence.addSC("input", "received packets");

            intBriC.no.ip.accounting.precedence.addSC("output", "transmitted packets");

      intBriC.no.ip.addSC("address", "Set the IP address of an interface");

         intBriC.no.ip.address.addSC("A.B.C.D", "IP address");

            intBriC.no.ip.address["A.B.C.D"].addSC("A.B.C.D", "IP subnet mask");

               intBriC.no.ip.address["A.B.C.D"]["A.B.C.D"].addSC("secondary", "Make this IP address a secondary address");

         intBriC.no.ip.address.addSC("negotiated", "IP Address negotiated over PPP");

            intBriC.no.ip.address.negotiated.addSC("previous", "IPCP attempts to negotiate previous address assigned");

      intBriC.no.ip.addSC("authentication", "authentication subcommands");

      intBriC.no.ip.addSC("bandwidth-percent", "Set EIGRP bandwidth limit");

         intBriC.no.ip["bandwidth-percent"].addSC("eigrp", "Enhanced Interior Gateway Routing Protocol (EIGRP)");

            intBriC.no.ip["bandwidth-percent"].eigrp.addSC("<1-65535>", "Autonomous system number");

      intBriC.no.ip.addSC("bgp", "BGP interface commands");

         intBriC.no.ip.bgp.addSC("fast-external-fallover", "Over-ride bgp global fast-failover whenexternal peer goes down");

      intBriC.no.ip.addSC("broadcast-address", "Set the broadcast address of an interface");

      intBriC.no.ip.addSC("cef", "Cisco Express Fowarding interface commands");

         intBriC.no.ip.cef.addSC("accounting", "CEF accounting features for interface");

            intBriC.no.ip.cef.accounting.addSC("non-recursive", "CEF non-recursive accounting features");

               intBriC.no.ip.cef.accounting["non-recursive"].addSC("external", "Count input traffic in non-recursive external bin");

               intBriC.no.ip.cef.accounting["non-recursive"].addSC("internal", "Count input traffic in non-recursive internal bin");

      intBriC.no.ip.addSC("cgmp", "Enable/disable CGMP");

      intBriC.no.ip.addSC("dhcp", "Configure DHCP parameters for this interface");

         intBriC.no.ip.dhcp.addSC("relay", "DHCP relay configuration parameters");

            intBriC.no.ip.dhcp.relay.addSC("information", "DHCP relay information option");

               intBriC.no.ip.dhcp.relay.information.addSC("trusted", "Received DHCP packet may contain relay info option with zero giaddr");

      intBriC.no.ip.addSC("directed-broadcast", "Enable forwarding of directed broadcasts");

      intBriC.no.ip.addSC("dvmrp", "DVMRP interface commands");

         intBriC.no.ip.dvmrp.addSC("accept-filter", "DVMRP incoming Report filters");

            intBriC.no.ip.dvmrp["accept-filter"].addSC("<1-99>", "Access list number");

      intBriC.no.ip.addSC("hello-interval", "Configures IP-EIGRP hello interval");

         intBriC.no.ip["hello-interval"].addSC("eigrp", "Enhanced Interior Gateway Routing Protocol (EIGRP)");

            intBriC.no.ip["hello-interval"].eigrp.addSC("<1-65535>", "Autonomous system number");

      intBriC.no.ip.addSC("helper-address", "Specify a destination address for UDP broadcasts");

         intBriC.no.ip["helper-address"].addSC("A.B.C.D", "IP destination address");

      intBriC.no.ip.addSC("hold-time", "Configures IP-EIGRP hold time");

         intBriC.no.ip["hold-time"].addSC("eigrp", "Enhanced Interior Gateway Routing Protocol (EIGRP)");

            intBriC.no.ip["hold-time"].eigrp.addSC("<1-65535>", "Autonomous system number");

      intBriC.no.ip.addSC("igmp", "IGMP interface commands");

         intBriC.no.ip.igmp.addSC("access-group", "IGMP group access group");

         intBriC.no.ip.igmp.addSC("helper-address", "IGMP helper address");

      intBriC.no.ip.addSC("irdp", "ICMP Router Discovery Protocol");

         intBriC.no.ip.irdp.addSC("address", "addresses to proxy-advertise");

            intBriC.no.ip.irdp.address.addSC("A.B.C.D", "address to advertise");

               intBriC.no.ip.irdp.address["A.B.C.D"].addSC("<-2147483648 - 2147483647>", "preference for this address");

         intBriC.no.ip.irdp.addSC("holdtime", "how long a receiver should believe the information");

         intBriC.no.ip.irdp.addSC("maxadvertinterval", "maximum time between advertisements");

         intBriC.no.ip.irdp.addSC("minadvertinterval", "minimum time between advertisements");

         intBriC.no.ip.irdp.addSC("multicast", "advertisements are sent with multicasts");

         intBriC.no.ip.irdp.addSC("preference", "preference level for this interface");

            intBriC.no.ip.irdp.preference.addSC("<-2147483648 - 2147483647>", "preference for this address (higher values preferred)");

      intBriC.no.ip.addSC("load-sharing", "Style of load sharing");

         intBriC.no.ip["load-sharing"].addSC("per-packet", "Random distribution");

      intBriC.no.ip.addSC("mask-reply", "Enable sending ICMP Mask Reply messages");

      intBriC.no.ip.addSC("mrm", "Configure IP Multicast Routing Monitor tester");

      intBriC.no.ip.addSC("mroute-cache", "Enable switching cache for incoming multicast packets");

      intBriC.no.ip.addSC("mtu", "Set IP Maximum Transmission Unit");

      intBriC.no.ip.addSC("multicast", "IP multicast interface commands");

         intBriC.no.ip.multicast.addSC("boundary", "Boundary for administratively scoped multicast addresses");

      intBriC.no.ip.addSC("nat", "NAT interface commands");

         intBriC.no.ip.nat.addSC("inside", "Inside interface for address translation");

         intBriC.no.ip.nat.addSC("outside", "Outside interface for address translation");

      intBriC.no.ip.addSC("nbar", "Network-Based Application Recognition");

         intBriC.no.ip.nbar.addSC("protocol-discovery", "Enable NBAR protocol discovery");

      intBriC.no.ip.addSC("nhrp", "NHRP interface subcommands");

         intBriC.no.ip.nhrp.addSC("authentication", "Authentication string");

      intBriC.no.ip.addSC("ospf", "OSPF interface commands");

      intBriC.no.ip.addSC("pim", "PIM interface commands");

      intBriC.no.ip.addSC("policy", "Enable policy routing");

         intBriC.no.ip.policy.addSC("route-map", "Policy route map");

            intBriC.no.ip.policy["route-map"].addSC("WORD", "Route map name");

      intBriC.no.ip.addSC("probe", "Enable HP Probe support");

         intBriC.no.ip.probe.addSC("proxy", "Proxy support");

      intBriC.no.ip.addSC("proxy-arp", "Enable proxy ARP");

      intBriC.no.ip.addSC("rarp-server", "Enable RARP server for static arp entries");

      intBriC.no.ip.addSC("redirects", "Enable sending ICMP Redirect messages");

      intBriC.no.ip.addSC("rgmp", "Enable/disable RGMP");

      intBriC.no.ip.addSC("rip", "Router Information Protocol");

         intBriC.no.ip.rip.addSC("authentication", "Authentication control");

      intBriC.no.ip.addSC("route-cache", "Enable fast-switching cache for outgoing packets");

         intBriC.no.ip["route-cache"].addSC("cef", "Enable Cisco Express Forwarding");

         intBriC.no.ip["route-cache"].addSC("flow", "Enable Flow fast-switching cache");

         intBriC.no.ip["route-cache"].addSC("policy", "Enable fast-switching policy cache for outgoing packets");

         intBriC.no.ip["route-cache"].addSC("same-interface", "Enable fast-switching on the same interface");

      intBriC.no.ip.addSC("rsvp", "RSVP interface commands");

         intBriC.no.ip.rsvp.addSC("bandwidth", "RSVP reservable bandwidth(KBPS)");

            intBriC.no.ip.rsvp.bandwidth.addSC("<1-10000000>", "Reservable Bandwidth(KBPS)");

               intBriC.no.ip.rsvp.bandwidth["<1-10000000>"].addSC("<1-10000000>", "Largest Reservable Flow(KBPS)");

      intBriC.no.ip.addSC("rtp", "RTP parameters");

         intBriC.no.ip.rtp.addSC("compression-connections", "Maximum number of compressed connections");

         intBriC.no.ip.rtp.addSC("header-compression", "Enable RTP header compression");

         intBriC.no.ip.rtp.addSC("priority", "Assign a priority queue for RTP streams");

         intBriC.no.ip.rtp.addSC("reserve", "Assign a reserved queue for RTP streams");

      intBriC.no.ip.addSC("sap", "Session Announcement Protocol interface commands");

         intBriC.no.ip.sap.addSC("listen", "Listen for sap packets on interface");

      intBriC.no.ip.addSC("security", "DDN IP Security Option");

         intBriC.no.ip.security.addSC("add", "Ensure all outgoing packets have a basic security option");

         intBriC.no.ip.security.addSC("aeso", "Specify AESO sources");

      intBriC.no.ip.addSC("split-horizon", "Perform split horizon");

         intBriC.no.ip["split-horizon"].addSC("eigrp", "Enhanced Interior Gateway Routing Protocol (EIGRP)");

            intBriC.no.ip["split-horizon"].eigrp.addSC("<1-65535>", "Autonomous system number");

      intBriC.no.ip.addSC("summary-address", "Perform address summarization");

         intBriC.no.ip["summary-address"].addSC("eigrp", "Enhanced Interior Gateway Routing Protocol (EIGRP)");

            intBriC.no.ip["summary-address"].eigrp.addSC("<1-65535>", "Autonomous system number");

               intBriC.no.ip["summary-address"].eigrp["<1-65535>"].addSC("A.B.C.D", "IP address");

                  intBriC.no.ip["summary-address"].eigrp["<1-65535>"]["A.B.C.D"].addSC("A.B.C.D", "IP network mask");

         intBriC.no.ip["summary-address"].addSC("rip", "Routing Information Protocol (RIP)");

            intBriC.no.ip["summary-address"].rip.addSC("A.B.C.D", "IP address");

               intBriC.no.ip["summary-address"].rip["A.B.C.D"].addSC("A.B.C.D", "IP network mask");

      intBriC.no.ip.addSC("tcp", "TCP header compression parameters");

         intBriC.no.ip.tcp.addSC("compression-connections", "Maximum number of compressed connections");

         intBriC.no.ip.tcp.addSC("header-compression", "Enable TCP header compression");

      intBriC.no.ip.addSC("trigger-authentication", "Enable trigger-authentication");

      intBriC.no.ip.addSC("unnumbered", "Enable IP processing without an explicit address");

      intBriC.no.ip.addSC("unreachables", "Enable sending ICMP Unreachable messages");

      intBriC.no.ip.addSC("urd", "Configure URL Rendezvousing");

         intBriC.no.ip.urd.addSC("proxy", "Enable IP URD proxy service");

      intBriC.no.ip.addSC("verify", "Enable per packet validation");

   intBriC.no.addSC("isdn", "ISDN Interface configuration commands");

      intBriC.no.isdn.addSC("T306", "Specify Timer T306 in milliseconds");

      intBriC.no.isdn.addSC("T310", "Specify Timer T310 in milliseconds");

      intBriC.no.isdn.addSC("all-incoming-calls-v120", "Answer all incoming calls as V.120");

      intBriC.no.isdn.addSC("answer1", "Specify Called Party number and subaddress");

         intBriC.no.isdn.answer1.addSC("WORD", "answer1 Number");

   intBriC.no.addSC("keepalive", "Enable keepalive");

      intBriC.no.keepalive.addSC("<0-32767>", "Keepalive period (default 10 seconds)");

   intBriC.no.addSC("line-power", "Provide power on the line.");

   intBriC.no.addSC("llc2", "LLC2 Interface Subcommands");

   intBriC.no.addSC("load-interval", "Specify interval for load calculation for an interface");

   intBriC.no.addSC("logging", "Configure logging for interface");

      intBriC.no.logging.addSC("event", "Interface events");

         intBriC.no.logging.event.addSC("link-status", "UPDOWN and CHANGE messages");

   intBriC.no.addSC("mac-address", "Manually set interface MAC address");

   intBriC.no.addSC("max-reserved-bandwidth", "Maximum Reservable Bandwidth on an Interface");

      intBriC.no["max-reserved-bandwidth"].addSC("<1-100>", "Max. reservable bandwidth as % of interface bandwidth");

   intBriC.no.addSC("mtu", "Set the interface Maximum Transmission Unit (MTU)");

   intBriC.no.addSC("multilink-group", "Put interface in a multilink bundle");

   intBriC.no.addSC("netbios", "Use a defined NETBIOS access list or enable name-caching");

      intBriC.no.netbios.addSC("input-access-filter", "Access list filter on incoming messages");

         intBriC.no.netbios["input-access-filter"].addSC("bytes", "Filter packets with declared byte offset access list filter");



   intBriC.no.addSC("shutdown","Shutdown the selected interface");





intBriC.addSC("ntp", "Configure NTP");

intBriC.addSC("ppp", "Point-to-Point Protocol");

   intBriC.ppp.addSC("accm", "Set initial Async Control Character Map");

      intBriC.ppp.accm.addSC("<0x0-0xFFFFFFFF>", "Async Control Character Map (in hex)");

   intBriC.ppp.addSC("acfc", "Options for HDLC Address & Control Field Compression");

      intBriC.ppp.acfc.addSC("local", "Specify use of ACFC option in outbound Config-Requests");

         intBriC.ppp.acfc.local.addSC("forbid", "Do not include ACFC option in our Config-Requests, ever");

         intBriC.ppp.acfc.local.addSC("request", "Include ACFC option in our Config-Requests");

      intBriC.ppp.acfc.addSC("remote", "Specify handling of ACFC option in inbound Config-Requests");

         intBriC.ppp.acfc.remote.addSC("apply", "Do ACFC if peer indicates it can receive such frames");

         intBriC.ppp.acfc.remote.addSC("ignore", "Accept ACFC option, but do not apply ACFC on outbound frames");

         intBriC.ppp.acfc.remote.addSC("reject", "Explicitly reject the ACFC option and disallow ACFC");

   intBriC.ppp.addSC("authentication", "Set PPP link authentication method");

      intBriC.ppp.authentication.addSC("chap", "Challenge Handshake Authentication Protocol (CHAP)");

         intBriC.ppp.authentication.chap.addSC("callback", "Authenticate remote on callback only");

         intBriC.ppp.authentication.chap.addSC("callin", "Authenticate remote on incoming call only");

            intBriC.ppp.authentication.chap.callin.addSC("callback", "Authenticate remote on callback only");

         intBriC.ppp.authentication.chap.addSC("callout", "Authenticate remote on outgoing call only");

            intBriC.ppp.authentication.chap.callout.addSC("callback", "Authenticate remote on callback only");

            intBriC.ppp.authentication.chap.callout.addSC("callin", "Authenticate remote on incoming call only");

               intBriC.ppp.authentication.chap.callout.callin.addSC("callback", "Authenticate remote on callback only");

         intBriC.ppp.authentication.chap.addSC("optional", "Allow peer to refuse to authenticate");

      intBriC.ppp.authentication.addSC("ms-chap", "Microsoft Challenge Handshake Authentication Protocol (MS-CHAP)");

         intBriC.ppp.authentication["ms-chap"].addSC("callback", "Authenticate remote on callback only");

         intBriC.ppp.authentication["ms-chap"].addSC("callin", "Authenticate remote on incoming call only");

            intBriC.ppp.authentication["ms-chap"].callin.addSC("callback", "Authenticate remote on callback only");

         intBriC.ppp.authentication["ms-chap"].addSC("callout", "Authenticate remote on outgoing call only");

            intBriC.ppp.authentication["ms-chap"].callout.addSC("callback", "Authenticate remote on callback only");

            intBriC.ppp.authentication["ms-chap"].callout.addSC("callin", "Authenticate remote on incoming call only");

               intBriC.ppp.authentication["ms-chap"].callout.callin.addSC("callback", "Authenticate remote on callback only");

         intBriC.ppp.authentication["ms-chap"].addSC("chap", "Challenge Handshake Authentication Protocol (CHAP)");

            intBriC.ppp.authentication["ms-chap"].chap.addSC("callback", "Authenticate remote on callback only");

            intBriC.ppp.authentication["ms-chap"].chap.addSC("callin", "Authenticate remote on incoming call only");

               intBriC.ppp.authentication["ms-chap"].chap.callin.addSC("callback", "Authenticate remote on callback only");

            intBriC.ppp.authentication["ms-chap"].chap.addSC("callout", "Authenticate remote on outgoing call only");

               intBriC.ppp.authentication["ms-chap"].chap.callout.addSC("callback", "Authenticate remote on callback only");

               intBriC.ppp.authentication["ms-chap"].chap.callout.addSC("callin", "Authenticate remote on incoming call only");

                  intBriC.ppp.authentication["ms-chap"].chap.callout.callin.addSC("callback", "Authenticate remote on callback only");

         intBriC.ppp.authentication["ms-chap"].addSC("optional", "Allow peer to refuse to authenticate");

      intBriC.ppp.authentication.addSC("pap", "Password Authentication Protocol (PAP)");

         intBriC.ppp.authentication.pap.addSC("callback", "Authenticate remote on callback only");

         intBriC.ppp.authentication.pap.addSC("callin", "Authenticate remote on incoming call only");

            intBriC.ppp.authentication.pap.callin.addSC("callback", "Authenticate remote on callback only");

         intBriC.ppp.authentication.pap.addSC("callout", "Authenticate remote on outgoing call only");

            intBriC.ppp.authentication.pap.callout.addSC("callback", "Authenticate remote on callback only");

            intBriC.ppp.authentication.pap.callout.addSC("callin", "Authenticate remote on incoming call only");

               intBriC.ppp.authentication.pap.callout.callin.addSC("callback", "Authenticate remote on callback only");

         intBriC.ppp.authentication.pap.addSC("chap", "Challenge Handshake Authentication Protocol (CHAP)");

            intBriC.ppp.authentication.pap.chap.addSC("callback", "Authenticate remote on callback only");

            intBriC.ppp.authentication.pap.chap.addSC("callin", "Authenticate remote on incoming call only");

               intBriC.ppp.authentication.pap.chap.callin.addSC("callback", "Authenticate remote on callback only");

            intBriC.ppp.authentication.pap.chap.addSC("callout", "Authenticate remote on outgoing call only");

               intBriC.ppp.authentication.pap.chap.callout.addSC("callback", "Authenticate remote on callback only");

               intBriC.ppp.authentication.pap.chap.callout.addSC("callin", "Authenticate remote on incoming call only");

                  intBriC.ppp.authentication.pap.chap.callout.callin.addSC("callback", "Authenticate remote on callback only");

         intBriC.ppp.authentication.pap.addSC("ms-chap", "Microsoft Challenge Handshake Authentication Protocol (MS-CHAP)");

            intBriC.ppp.authentication.pap["ms-chap"].addSC("callback", "Authenticate remote on callback only");

            intBriC.ppp.authentication.pap["ms-chap"].addSC("callin", "Authenticate remote on incoming call only");

               intBriC.ppp.authentication.pap["ms-chap"].callin.addSC("callback", "Authenticate remote on callback only");

            intBriC.ppp.authentication.pap["ms-chap"].addSC("callout", "Authenticate remote on outgoing call only");

               intBriC.ppp.authentication.pap["ms-chap"].callout.addSC("callback", "Authenticate remote on callback only");

               intBriC.ppp.authentication.pap["ms-chap"].callout.addSC("callin", "Authenticate remote on incoming call only");

                  intBriC.ppp.authentication.pap["ms-chap"].callout.callin.addSC("callback", "Authenticate remote on callback only");

            intBriC.ppp.authentication.pap["ms-chap"].addSC("chap", "Challenge Handshake Authentication Protocol (CHAP)");

               intBriC.ppp.authentication.pap["ms-chap"].chap.addSC("callback", "Authenticate remote on callback only");

               intBriC.ppp.authentication.pap["ms-chap"].chap.addSC("callin", "Authenticate remote on incoming call only");

                  intBriC.ppp.authentication.pap["ms-chap"].chap.callin.addSC("callback", "Authenticate remote on callback only");

               intBriC.ppp.authentication.pap["ms-chap"].chap.addSC("callout", "Authenticate remote on outgoing call only");

                  intBriC.ppp.authentication.pap["ms-chap"].chap.callout.addSC("callback", "Authenticate remote on callback only");

                  intBriC.ppp.authentication.pap["ms-chap"].chap.callout.addSC("callin", "Authenticate remote on incoming call only");

                     intBriC.ppp.authentication.pap["ms-chap"].chap.callout.callin.addSC("callback", "Authenticate remote on callback only");

         intBriC.ppp.authentication.pap.addSC("optional", "Allow peer to refuse to authenticate");

   intBriC.ppp.addSC("bap", "Set BAP bandwidth allocation parameters");

      intBriC.ppp.bap.addSC("call", "Set BAP call parameters");

         intBriC.ppp.bap.call.addSC("accept", "Allow a peer to initiate link addition (default)");

         intBriC.ppp.bap.call.addSC("request", "Initiate the addition of a link");

         intBriC.ppp.bap.call.addSC("timer", "Time to wait between sending call requests in seconds");

            intBriC.ppp.bap.call.timer.addSC("<2-120>", "Timer value");

      intBriC.ppp.bap.addSC("callback", "Set BAP callback parameters");

         intBriC.ppp.bap.callback.addSC("accept", "Initiate link addition upon peer notification");

         intBriC.ppp.bap.callback.addSC("request", "Request that a peer initiate link addition");

         intBriC.ppp.bap.callback.addSC("timer", "Time to wait between sending callback requests in seconds");

            intBriC.ppp.bap.callback.timer.addSC("<2-120>", "Timer value");

      intBriC.ppp.bap.addSC("drop", "Set BAP link drop parameters");

         intBriC.ppp.bap.drop.addSC("accept", "Allow a peer to initiate link removal (default)");

         intBriC.ppp.bap.drop.addSC("after-retries", "Remove the link after no response to drop requests");

         intBriC.ppp.bap.drop.addSC("request", "Initiate the removal of a link (default)");

         intBriC.ppp.bap.drop.addSC("timer", "Time to wait between sending link drop requests in seconds");

            intBriC.ppp.bap.drop.timer.addSC("<2-120>", "Timer value");

      intBriC.ppp.bap.addSC("link", "Set BAP link specific parameters");

         intBriC.ppp.bap.link.addSC("types", "Specify the link types applicable for addition (isdn default)");

            intBriC.ppp.bap.link.types.addSC("analog", "Synchronous or asynchronous interfaces");

            intBriC.ppp.bap.link.types.addSC("isdn", "ISDN interface");

               intBriC.ppp.bap.link.types.isdn.addSC("analog", "Synchronous or asynchronous interfaces");

      intBriC.ppp.bap.addSC("max", "Set BAP limits on retries and dialers");

         intBriC.ppp.bap.max.addSC("dial-attempts", "Maximum number of dial attempts for a number (1 default)");

            intBriC.ppp.bap.max["dial-attempts"].addSC("<1-3>", "Number of attempts");

         intBriC.ppp.bap.max.addSC("dialers", "Maximum number of free dialers to search for (5 default)");

            intBriC.ppp.bap.max.dialers.addSC("<1-10>", "Number of free dialers");

         intBriC.ppp.bap.max.addSC("ind-retries", "Maximum number of retries of a call status indication (3 default)");

            intBriC.ppp.bap.max["ind-retries"].addSC("<1-10>", "Number of retries");

         intBriC.ppp.bap.max.addSC("req-retries", "Maximum number of retries for a particular request (3 default)");

            intBriC.ppp.bap.max["req-retries"].addSC("<1-5>", "Number of retries");

      intBriC.ppp.bap.addSC("monitor", "Enable BAP monitoring of operational values");

         intBriC.ppp.bap.monitor.addSC("load", "Validate peer requests against load thresholds (default)");

      intBriC.ppp.bap.addSC("number", "Phone numbers which a peer can dial to connect");

         intBriC.ppp.bap.number.addSC("default", "A base phone number which can be used to dial in");

         intBriC.ppp.bap.number.addSC("format", "Phone number format for both incoming and outgoing calls");

            intBriC.ppp.bap.number.format.addSC("national", "Format is a three digit area-code + seven digit subscriber number");

            intBriC.ppp.bap.number.format.addSC("subscriber", "Format is a seven digit subscriber number");

         intBriC.ppp.bap.number.addSC("prefix", "Specify a prefix to be used for outgoing dial attempts");

            intBriC.ppp.bap.number.prefix.addSC("WORD", "Phone number prefix");

         intBriC.ppp.bap.number.addSC("secondary", "A secondary phone number which can be used to dial in");

            intBriC.ppp.bap.number.secondary.addSC("WORD", "Phone number (incoming)");

      intBriC.ppp.bap.addSC("timeout", "Set BAP action timeouts");

         intBriC.ppp.bap.timeout.addSC("pending", "Pending action timeout in seconds (20 default)");

            intBriC.ppp.bap.timeout.pending.addSC("<2-90>", "Timer value");

         intBriC.ppp.bap.timeout.addSC("response", "Response timeout in seconds (3 default)");

            intBriC.ppp.bap.timeout.response.addSC("<2-10>", "Timer value");

   intBriC.ppp.addSC("bridge", "Enable PPP bridge translation");

      intBriC.ppp.bridge.addSC("appletalk", "Bridge Appletalk traffic");

      intBriC.ppp.bridge.addSC("ip", "Bridge IP traffic");

      intBriC.ppp.bridge.addSC("ipx", "Bridge IPX traffic");

         intBriC.ppp.bridge.ipx.addSC("arpa", "Novell Ethernet_II");

         intBriC.ppp.bridge.ipx.addSC("novell-ether", "Novell Ethernet_802.3");

         intBriC.ppp.bridge.ipx.addSC("sap", "IEEE 802.2 on bridged IPX traffic");

         intBriC.ppp.bridge.ipx.addSC("snap", "IEEE 802.2 SNAP on bridged IPX traffic");

   intBriC.ppp.addSC("callback", "Set PPP link callback option");

      intBriC.ppp.callback.addSC("accept", "Accept a callback request");

      intBriC.ppp.callback.addSC("permit", "Permit a callback");

      intBriC.ppp.callback.addSC("request", "Request a callback");

   intBriC.ppp.addSC("chap", "Set CHAP authentication parameters");

      intBriC.ppp.chap.addSC("hostname", "Set alternate CHAP hostname");

         intBriC.ppp.chap.hostname.addSC("WORD", "Alternate CHAP hostname");

      intBriC.ppp.chap.addSC("password", "Set default CHAP password");

         intBriC.ppp.chap.password.addSC("<0-7>", "Encryption type (0=not yet encrypted)");

            intBriC.ppp.chap.password["<0-7>"].addSC("LINE", "Default PPP authentication password");

      intBriC.ppp.chap.addSC("refuse", "Refuse to authenticate using CHAP");

         intBriC.ppp.chap.refuse.addSC("callin", "Refuse to authenticate on incoming call only");

      intBriC.ppp.chap.addSC("wait", "Wait for caller to authenticate first");

   intBriC.ppp.addSC("ipcp", "Set IPCP negotiation options");

      intBriC.ppp.ipcp.addSC("accept-address", "Accept any non zero IP address from our peer");

      intBriC.ppp.ipcp.addSC("dns", "Specify DNS negotiation options");

         intBriC.ppp.ipcp.dns.addSC("A.B.C.D", "Primary DNS IP address");

            intBriC.ppp.ipcp.dns["A.B.C.D"].addSC("A.B.C.D", "Secondary DNS IP address");

         intBriC.ppp.ipcp.dns.addSC("accept", "Accept any non zero DNS address");

         intBriC.ppp.ipcp.dns.addSC("reject", "Reject negotiations with the peer");

         intBriC.ppp.ipcp.dns.addSC("request", "Request server addresses from peer");

      intBriC.ppp.ipcp.addSC("header-compression", "IPCP header compression option");

         intBriC.ppp.ipcp["header-compression"].addSC("ack", "Ack IP HC option if IP HC is disabled");

      intBriC.ppp.ipcp.addSC("ignore-map", "Ignore dialer map when negotiating peer IP address");

      intBriC.ppp.ipcp.addSC("mask", "Specify subnet mask negotiation options");

         intBriC.ppp.ipcp.mask.addSC("A.B.C.D", "Subnet mask to offer peer");

         intBriC.ppp.ipcp.mask.addSC("reject", "Reject subnet mask negotation from peer");

         intBriC.ppp.ipcp.mask.addSC("request", "Request subnet mask from peer (VSO)");

      intBriC.ppp.ipcp.addSC("username", "Configure how usernames are handled");

         intBriC.ppp.ipcp.username.addSC("unique", "Append information to make username unique");

      intBriC.ppp.ipcp.addSC("wins", "Specify WINS negotiation options");

         intBriC.ppp.ipcp.wins.addSC("A.B.C.D", "Primary WINS IP address");

            intBriC.ppp.ipcp.wins["A.B.C.D"].addSC("A.B.C.D", "Secondary WINS IP address");

         intBriC.ppp.ipcp.wins.addSC("accept", "Accept any non zero WINS address");

         intBriC.ppp.ipcp.wins.addSC("reject", "Reject negotiations with the peer");

         intBriC.ppp.ipcp.wins.addSC("request", "Request server addresses from peer");

   intBriC.ppp.addSC("lcp", "PPP LCP configuration");

      intBriC.ppp.lcp.addSC("delay", "Delay before PPP sends first packet");

         intBriC.ppp.lcp.delay.addSC("<1-255>", "Seconds");

      intBriC.ppp.lcp.addSC("fast-start", "Ignore Carrier Timer, Start PPP when an LCP pkt arrives");

   intBriC.ppp.addSC("link", "Set miscellaneous link parameters");

      intBriC.ppp.link.addSC("reorders", "Advise that packets may be received out of order");

   intBriC.ppp.addSC("max-bad-auth", "Allow multiple authentication failures");

      intBriC.ppp["max-bad-auth"].addSC("<1-255>", "Number of attempts allowed");

   intBriC.ppp.addSC("multilink", "Make interface multilink capable");

      intBriC.ppp.multilink.addSC("bap", "Enable BACP/BAP bandwidth allocation negotiation");

         intBriC.ppp.multilink.bap.addSC("required", "Disconnect multilink bundle if BACP is not negotiated");

      intBriC.ppp.multilink.addSC("endpoint", "Configure the local Endpoint Discriminator");

         intBriC.ppp.multilink.endpoint.addSC("hostname", "Use router's hostname");

         intBriC.ppp.multilink.endpoint.addSC("ip", "Use IP address");

            intBriC.ppp.multilink.endpoint.ip.addSC("A.B.C.D", "IP address");

         intBriC.ppp.multilink.endpoint.addSC("mac", "Use MAC address from a LAN interface");

            intBriC.ppp.multilink.endpoint.mac.addSC("FastEthernet", "FastEthernet IEEE 802.3");

               intBriC.ppp.multilink.endpoint.mac.FastEthernet.addSC("<0-1>", "FastEthernet interface number");

         intBriC.ppp.multilink.endpoint.addSC("none", "Do not supply an Endpoint Discriminator");

         intBriC.ppp.multilink.endpoint.addSC("phone", "Use Public Switched Telephone Network directory number");

            intBriC.ppp.multilink.endpoint.phone.addSC("LINE", "Telephone number");

         intBriC.ppp.multilink.endpoint.addSC("string", "Use specified string");

            intBriC.ppp.multilink.endpoint.string.addSC("LINE", "String to use as Endpoint Discriminator");

      intBriC.ppp.multilink.addSC("group", "Put interface in a multilink bundle");

         intBriC.ppp.multilink.group.addSC("<1-2147483647>", "Multilink group number");

      intBriC.ppp.multilink.addSC("queue", "Specify link queuing parameters");

         intBriC.ppp.multilink.queue.addSC("depth", "Specify maximum depth for link transmit queues");

            intBriC.ppp.multilink.queue.depth.addSC("fifo", "Set max depth for link queues when bundle has FIFO queuing");

               intBriC.ppp.multilink.queue.depth.fifo.addSC("<2-255>", "Max queue depth for link");

            intBriC.ppp.multilink.queue.depth.addSC("qos", "Set max depth for link queues when bundle has non-FIFO queuing");

               intBriC.ppp.multilink.queue.depth.qos.addSC("<2-255>", "Max queue depth for link");

   intBriC.ppp.addSC("pap", "Set PAP authentication parameters");

      intBriC.ppp.pap.addSC("refuse", "Refuse to authenticate using PAP");

         intBriC.ppp.pap.refuse.addSC("callin", "Refuse to authenticate on incoming call only");

      intBriC.ppp.pap.addSC("sent-username", "Set outbound PAP username");

         intBriC.ppp.pap["sent-username"].addSC("WORD", "Outbound PAP username");

            intBriC.ppp.pap["sent-username"].WORD.addSC("password", "Set outbound PAP password");

               intBriC.ppp.pap["sent-username"].WORD.password.addSC("<0-7>", "Encryption type (0=not yet encrypted)");

                  intBriC.ppp.pap["sent-username"].WORD.password["<0-7>"].addSC("LINE", "Outbound PAP password");

   intBriC.ppp.addSC("pfc", "Options for Protocol Field Compression");

      intBriC.ppp.pfc.addSC("local", "Specify use of PFC option in outbound Config-Requests");

         intBriC.ppp.pfc.local.addSC("forbid", "Do not include PFC option in our Config-Requests, ever");

         intBriC.ppp.pfc.local.addSC("request", "Include PFC option in our Config-Requests");

      intBriC.ppp.pfc.addSC("remote", "Specify handling of PFC option in inbound Config-Requests");

         intBriC.ppp.pfc.remote.addSC("apply", "Do PFC if peer indicates it can receive such frames");

         intBriC.ppp.pfc.remote.addSC("ignore", "Accept PFC option, but do not apply PFC on outbound frames");

         intBriC.ppp.pfc.remote.addSC("reject", "Explicitly reject the PFC option and disallow PFC");

   intBriC.ppp.addSC("quality", "Set minimum Link Quality before link is down");

      intBriC.ppp.quality.addSC("<0-100>", "Percent of traffic successful");

   intBriC.ppp.addSC("reliable-link", "Use LAPB with PPP to provide a reliable link");

   intBriC.ppp.addSC("timeout", "Set PPP timeout parameters");

      intBriC.ppp.timeout.addSC("authentication", "Maximum time to wait for an authentication response");

         intBriC.ppp.timeout.authentication.addSC("<0-255>", "Seconds");

      intBriC.ppp.timeout.addSC("idle", "Specify idle timeout before disconnecting line");

         intBriC.ppp.timeout.idle.addSC("<1-2147483>", "Idle timeout before disconnecting a call");

            intBriC.ppp.timeout.idle["<1-2147483>"].addSC("either", "Reset idle timer based on either inbound or outbound traffic");

            intBriC.ppp.timeout.idle["<1-2147483>"].addSC("inbound", "Reset idle timer based on inbound traffic only");

      intBriC.ppp.timeout.addSC("ncp", "Maximum time to wait for network layer to negotiate");

         intBriC.ppp.timeout.ncp.addSC("<1-65535>", "Seconds");

      intBriC.ppp.timeout.addSC("retry", "Maximum time to wait for a response during PPP negotiation");

         intBriC.ppp.timeout.retry.addSC("<1-255>", "Seconds");

   intBriC.ppp.addSC("use-tacacs", "Use TACACS to verify PPP authentications");

      intBriC.ppp["use-tacacs"].addSC("single-line", "Accept username and password in the username field");

intBriC.addSC("priority-group", "Assign a priority group to an interface");

   intBriC["priority-group"].addSC("<1-16>", "Priority group");

intBriC.addSC("pulse-time", "Force DTR low during resets");

intBriC.addSC("random-detect", "Enable Weighted Random Early Detection (WRED) on an Interface");

intBriC.addSC("rate-limit", "Rate Limit");

intBriC.addSC("serial", "serial interface commands");

intBriC.addSC("service-policy", "Configure QoS Service Policy");

intBriC.addSC("shutdown", "Shutdown the selected interface");

intBriC.addSC("smds", "Modify SMDS parameters");

intBriC.addSC("snapshot", "Configure snapshot support on the interface");

intBriC.addSC("snmp", "Modify SNMP interface parameters");

intBriC.addSC("source", "Get config from another source");

intBriC.addSC("timeout", "Define timeout values for this interface");

intBriC.addSC("transmit-interface", "Assign a transmit interface to a receive-only interface");

intBriC.addSC("trunk-group", "Configure interface to be in a trunk group");

intBriC.addSC("tx-ring-limit", "Configure PA level transmit ring limit");